java复习款

2023/8/13

后端

Object类、常用API

public String toString():返回该对象的字符串表示
public boolean equals(Object obj):指示其他某个对象是否与此对象“相等”
    
java.util.Date类表示特定的瞬间，精确到毫秒
    public Date():分配Date对象并初始化此对象，以表示分配它的时间(精确到秒)
    public Date(long date):分配Date对象并初始化此对象，以表示从标准基准时间1970年1月1日以来的指定毫秒数
    public long getTime():把日期对象转换成对应的时间毫秒值
    
java.text.DateFormat类是日期/时间格式化子类的抽象类
    public SimpleDateFormate(String pattern):用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat["yyyy-MM-dd HH:mm:ss" => 2018-01-16 15:06:38]
    public String format(Date date):将Date对象格式化为字符串
    public Date parse(String source):将字符串解析为Date对象

请使用日期时间相关的API，计算出一个人已经出生了多少天。

思路：

1.获取当前时间对应的毫秒值

2.获取自己出生日期对应的毫秒值

3.两个时间相减（当前时间– 出生日期）

代码实现：

public static void function() throws Exception {
    System.out.println("请输入出生日期 格式 YYYY-MM-dd");
    // 获取出生日期,键盘输入
    String birthdayString = new Scanner(System.in).next();
    // 将字符串日期,转成Date对象
    // 创建SimpleDateFormat对象,写日期模式
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    // 调用方法parse,字符串转成日期对象
    Date birthdayDate = sdf.parse(birthdayString);    
    // 获取今天的日期对象
    Date todayDate = new Date();    
    // 将两个日期转成毫秒值,Date类的方法getTime
    long birthdaySecond = birthdayDate.getTime();
    long todaySecond = todayDate.getTime();
    long secone = todaySecond-birthdaySecond;    
    if (secone < 0){
        System.out.println("还没出生呢");
    } else {
        System.out.println(secone/1000/60/60/24);
    }
}

Calendar类

java.util.Calendar
    public static Calendar getInstance():使用默认时区和语言环境获得一个日历
    public int get(int field):返回給定日历字段的值
    public void set(int field, int value):将给定的日历字段设置为定值
    public abstract void add(qint field, int amount):根据日历的规则，为給定的日历字段添加或减去指定的时间量
    public Date getTime():返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Da

public static void main(String[] args) {
    get方法
        Calendar cal = Calendar.getInstance();
        int year = cal.get(Calendar.YEAR);
        int month = cal.get(Calendar.MONTH)+1;
        int day = cal.get(Calendar.DAY_OF_MONTH);
        System.out.println(year+"年"+month+"月"+day+"日");
    }

    set方法
public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, 2020);
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); 
                        // 2020年1月17日
    }
    
    add方法
public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日");
                            // 2018年1月17日
        // 使用add方法
        cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
        cal.add(Calendar.YEAR, -3); // 减3年
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); 
                            // 2015年1月18日; 
    }

    getTime方法

CurrentTimeMillis方法

验证for循环打印数字1-9999所需要使用的时间（毫秒）

public class SystemTest1 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时毫秒：" + (end - start));
    }
}

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。(数组拷贝)

StringBuilder类

StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。

备注：StringBuilder已经覆盖重写了Object当中的toString方法。
public StringBuilder():构造一个空的StringBuilder容器
public StringBuilder(String str):构造一个StringBuilder容器，并将字符串添加进去
public StringBuilder append(...):添加任意类型数据的字符串形式，并返回当前对象自身
public String toString():将当前StringBuilder对象转换为String对象

append方法
public static void main(String[] args) {
        //创建对象
        StringBuilder builder = new StringBuilder();
        //public StringBuilder append(任意类型)
        StringBuilder builder2 = builder.append("hello");
        //对比一下
        System.out.println("builder:"+builder);
        System.out.println("builder2:"+builder2);
        System.out.println(builder == builder2); //true
        // 可以添加 任何类型
        builder.append("hello");
        builder.append("world");
        builder.append(true);
        builder.append(100);
        // 在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。
        // 这种时候，我们就可以把代码现在一起，如append方法一样，代码如下
        //链式编程
        builder.append("hello").append("world").append(true).append(100);
        System.out.println("builder:"+builder);
    }

toString方法
通过toString方法，StringBuilder对象将会转换为不可变的String对象。如：
public static void main(String[] args) {
        // 链式创建
        StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
        // 调用方法
        String str = sb.toString();
        System.out.println(str); // HelloWorldJava
    }

基本类型转换位String

- public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
- public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
- public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
- public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
- public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
- public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
- public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。
public class Demo18WrapperParse {
    public static void main(String[] args) {
        int num = Integer.parseInt("100");
    }
}

Collection、泛型

集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map，今天我们主要学习Collection集合。集合本身是一个工具，它存放在java.util包中。在Collection接口定义着单列集合框架中最最共性的内容。

public boolean add(E e):把给定的对象添加到当前集合中
public void clear():清空集合中所有的元素
public boolean remove(E e):把给定的对象在当前集合中删掉
public boolean contains(E e):判断当前集合中是否包含给定的对象
public boolean isEmpty():判断当前集合是否位空
public int size():返回集合中元素的个数
public Object[] to Array():把集合中的元素，存储到数组中

public static void main(String[] args) {
        Collection<String> coll = new ArrayList<String>();
        coll.add("一");
        coll.add("二");
        coll.add("三");
        System.out.println(coll);                //[一, 二, 三]
        System.out.println(coll.contains("二"));     //true
        System.out.println(coll.isEmpty());  //false
        System.out.println(coll.size());     //3
        System.out.println(coll.remove("二")); // true
        System.out.println(coll);                  //[一，二]
        System.out.println(coll.contains("二"));  //false

        Object[] objects = coll.toArray(); //0 1
        for (int i = 0; i < objects.length; i++) {
            System.out.println(i);
        }
    }

Iterator迭代器

JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。

public E next():返回迭代的下一个元素
public boolean hasNext():如果仍有元素可以迭代，则返回true

tips:：在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发生java.util.NoSuchElementException没有集合元素的错误。
public static void main(String[] args) {
        // 使用多态方式 创建对象
        Collection<String> coll = new ArrayList<String>();
        // 添加元素到集合
        coll.add("串串星人");
        coll.add("吐槽星人");
        coll.add("汪星人");
        //遍历
        //使用迭代器 遍历   每个集合对象都有自己的迭代器
        Iterator<String> it = coll.iterator();
        //  泛型指的是 迭代出 元素的数据类型
        while(it.hasNext()){ //判断是否有迭代元素
            String s = it.next();//获取迭代出的元素
            System.out.println(s);
        }
      }

增强for

它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

for(元素的数据类型 变量 ： collection集合or数组){
  //操作代码
}

遍历集合
public static void main(String[] args) {        
        Collection<String> coll = new ArrayList<String>();
        coll.add("小河神");
        coll.add("老河神");
        coll.add("神婆");
        //使用增强for遍历
        for(String s :coll){//接收变量s代表 代表被遍历到的集合元素
            System.out.println(s);
    }
}

泛型

修饰符 class 类名<代表泛型的变量> { }
class ArrayList<E>{
    public boolean add(E e) { }
    public E get(int index) { }
}

在创建对象的时候确定泛型
ArrayList<String> list = new ArrayList<String>();
class ArrayList<Integer>{
    public boolean add(Integer e) { }
    public Integer get(int index) { }
}

举例自定义泛型类
public class MyGenericClass<MVP>{
    //没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
    private MVP mvp;
    public void setMVP(MVP mvp){
        this.mvp = mvp;
    }
    public MVP getMVP(){
        return mvp;
    }
}

public class GenericClassDemo {
      public static void main(String[] args) {         
         // 创建一个泛型为String的类
         MyGenericClass<String> my = new MyGenericClass<String>();        
         // 调用setMVP
         my.setMVP("大胡子登登");
         // 调用getMVP
         String mvp = my.getMVP();
         System.out.println(mvp);
         //创建一个泛型为Integer的类
         MyGenericClass<Integer> my2 = new MyGenericClass<Integer>(); 
         my2.setMVP(123);         
         Integer mvp2 = my2.getMVP();
    }
}

含有泛型的方法

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

public class MyGenericMethod {      
    public <MVP> void show(MVP mvp) {
        System.out.println(mvp.getClass());
    }
    
    public <MVP> MVP show2(MVP mvp) {    
        return mvp;
    }
}

含有泛型的接口

1、定义类时确定泛型的类型

修饰符 interface接口名<代表泛型的变量> {  }

public interface MyGenericInterface<E>{
    public abstract void add(E e);
    
    public abstract E getE();  
}

泛型E的值就是String类型
public class MyImp1 implements MyGenericInterface<String> {
    @Override
    public void add(String e) {
        // 省略...
    }

    @Override
    public String getE() {
        return null;
    }
}

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

public class MyImp2<E> implements MyGenericInterface<E> {
    @Override
    public void add(E e) {
            // 省略...
    }

    @Override
    public E getE() {
        return null;
    }
}

/*
 * 使用
 */
public class GenericInterface {
    public static void main(String[] args) {
        MyImp2<String>  my = new MyImp2<String>();  
        my.add("aa");
    }
}

泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过**通配符<?>**表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

public static void main(String[] args) {
    Collection<Intger> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
}
public static void getElement(Collection<?> coll){}
//？代表可以接收任意类型

通配符高级使用—-受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

格式： 类型名称 <? extends 类 > 对象名称
意义： 只能接收该类型及其子类

泛型的下限：

格式： 类型名称 <? super 类 > 对象名称
意义： 只能接收该类型及其父类型

比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类

public static void main(String[] args) {
    Collection<Integer> list1 = new ArrayList<Integer>();
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
    
    getElement(list1);
    getElement(list2);//报错
    getElement(list3);
    getElement(list4);//报错
  
    getElement2(list1);//报错
    getElement2(list2);//报错
    getElement2(list3);
    getElement2(list4);
  
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}

Java.util.Collections类下有一个静态的shuffle()方法,如下：

1）static void shuffle(List<?> list)  使用默认随机源对列表进行置换，所有置换发生的可能性都是大致相等的。

2）static void shuffle(List<?> list, Random rand) 使用指定的随机源对指定列表进行置换，所有置换发生的可能性都是大致相等的，假定随机源是公平的。

扑克牌案例分析

准备牌：

牌可以设计为一个ArrayList,每个字符串为一张牌。
每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。
牌由Collections类的shuffle方法进行随机排序。
发牌

将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。
看牌

直接打印每个集合。

import java.util.ArrayList;
import java.util.Collections;

public class Poker {
    public static void main(String[] args) {
        /*
        * 1: 准备牌操作
        */
        //1.1 创建牌盒 将来存储牌面的 
        ArrayList<String> pokerBox = new ArrayList<String>();
        //1.2 创建花色集合
        ArrayList<String> colors = new ArrayList<String>();

        //1.3 创建数字集合
        ArrayList<String> numbers = new ArrayList<String>();

        //1.4 分别给花色 以及 数字集合添加元素
        colors.add("♥");
        colors.add("♦");
        colors.add("♠");
        colors.add("♣");

        for(int i = 2;i<=10;i++){
            numbers.add(i+"");
        }
        numbers.add("J");
        numbers.add("Q");
        numbers.add("K");
        numbers.add("A");
        //1.5 创造牌  拼接牌操作
        // 拿出每一个花色  然后跟每一个数字 进行结合  存储到牌盒中
        for (String color : colors) {
            //color每一个花色 
            //遍历数字集合
            for(String number : numbers){
                //结合
                String card = color+number;
                //存储到牌盒中
                pokerBox.add(card);
            }
        }
        //1.6大王小王
        pokerBox.add("小☺");
        pokerBox.add("大☠");      
        // System.out.println(pokerBox);
        //洗牌 是不是就是将  牌盒中 牌的索引打乱 
        // Collections类  工具类  都是 静态方法
        // shuffer方法   
        /*
         * static void shuffle(List<?> list) 
         *     使用默认随机源对指定列表进行置换。 
         */
        //2:洗牌
        Collections.shuffle(pokerBox);
        //3 发牌
        //3.1 创建 三个 玩家集合  创建一个底牌集合
        ArrayList<String> player1 = new ArrayList<String>();
        ArrayList<String> player2 = new ArrayList<String>();
        ArrayList<String> player3 = new ArrayList<String>();
        ArrayList<String> dipai = new ArrayList<String>();      

        //遍历 牌盒  必须知道索引   
        for(int i = 0;i<pokerBox.size();i++){
            //获取 牌面
            String card = pokerBox.get(i);
            //留出三张底牌 存到 底牌集合中
            if(i>=51){//存到底牌集合中
                dipai.add(card);
            } else {
                //玩家1   %3  ==0
                if(i%3==0){
                      player1.add(card);
                }else if(i%3==1){//玩家2
                      player2.add(card);
                }else{//玩家3
                      player3.add(card);
                }
            }
        }
        //看看
        System.out.println("令狐冲："+player1);
        System.out.println("田伯光："+player2);
        System.out.println("绿竹翁："+player3);
        System.out.println("底牌："+dipai);  
    }
}

List、Set、数据结构、Collections

List集合特有的方法都是跟索引相关

public void add(int index, E element):将指定的元素，添加到集合中的指定位置上
public E get(int index):返回集合中指定位置的元素
public E remove(int index):移除列表中指定位置的元素，返回的是被移除的元素
public E set(int index，E element):用指定元素替换集合中指定位置的元素，返回值的更新前的元素

public static void main(String[] args) {
        // 创建List集合对象
        List<String> list = new ArrayList<String>();
        
        // 往 尾部添加 指定元素
        list.add("图图");
        list.add("小美");
        list.add("不高兴");
        
        System.out.println(list);
        // add(int index,String s) 往指定位置添加
        list.add(1,"没头脑");
        
        System.out.println(list);
        // String remove(int index) 删除指定位置元素  返回被删除元素
        // 删除索引位置为2的元素 
        System.out.println("删除索引位置为2的元素");
        System.out.println(list.remove(2));
        
        System.out.println(list);
        
        // String set(int index,String s)
        // 在指定位置 进行 元素替代（改） 
        // 修改指定位置元素
        list.set(0, "三毛");
        System.out.println(list);
        
        // String get(int index)  获取指定位置元素
        
        // 跟size() 方法一起用  来 遍历的 
        for(int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        //还可以使用增强for
        for (String string : list) {
            System.out.println(string);
        }      
    }

List(ArrayList、LinkedList)的子类

java.util.ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。

public void addFirst(E e):将指定元素插入此列表的开头
public void addLast(E e):将指定元素添加到此列表的结尾
public E getFirst():返回此列表的第一个元素
public E removeFirst():移除并返回此列表的第一个元素
public E removeLast():移除并返回此列表的最后一个元素
public E pop():从此列表所表示的堆栈处弹出一个元素
public void push(E e):将元素推入此列表所表示的堆栈
public boolean isEmpty():如果列表不包含元素，则返回true

Set(HashSet、LinkedHashSet)

java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

Set集合有多个子类，这里我们介绍其中的java.util.HashSet、java.util.LinkedHashSet这两个集合。

Set集合取出元素的方式可以采用：迭代器、增强for

HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于：hashCode与equals方法。

HashSet存储自定义类型元素

给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一。

可变参数

修饰符 返回值类型 方法名(参数类型[] 形参名){  }
public static int getSum(int[] arr){
    int sum = 0;
    for(int a : arr){
        sum += a;
    }
    return sum;
}

Collections(高效添加元素)

java.utils.Collections是集合工具类
public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素
public static void shuffle(List<?> list):打乱集合顺序
public static <T> void sort(List<T> list):将集合中元素按照默认规则排序
public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。

 public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        //原来写法
        //list.add(12);
        //list.add(14);
        //list.add(15);
        //list.add(1000);
        //采用工具类 完成 往集合中添加元素  
        Collections.addAll(list, 5, 222, 1，2);
        System.out.println(list);
        //排序方法 
        Collections.sort(list);
        System.out.println(list);
    }
}

Comparator比较器

public int compare(String o1, String o2):比较两个参数的顺序
return o1 - o2 (正数)

public static void main(String[] args) {
   ArrayList<String> arr = new ArrayList<String>();
   Collections.addAll(arr,"cba","aba","sba","nba");
   Collections.sort(arr, new Comparator<String>() {
     @Override
     public int compare(String o1, String o2) {
         return o1.charAt(0)-o2.charAt(0);
     }
  });
  System.out.println(arr);
}

public class Student_test implements Comparable<Student_test> {
    @Override
    public int compareTo(Student_test o) {
        return this.age-o.age;
    }
Getter Setter toString 
--------------------------------------------------------------
public class Comparable_test {
    public static void main(String[] args) {
        ArrayList<Student_test> list = new ArrayList<Student_test>();
        list.add(new Student_test("rose",18));
        list.add(new Student_test("jack",16));
        list.add(new Student_test("abc",16));
        list.add(new Student_test("ace",17));
        list.add(new Student_test("mark",16));
        for(Student_test student : list){
            System.out.println(student);
        }
    }
}

如果在使用的时候，想要独立的定义规则去使用可以采用Collections.sort(List list,Comparetor c)方式，自己定义规则：

Collections.sort(list, new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return o2.getAge()-o1.getAge();//以学生的年龄降序
    }
});

Student{name='rose', age=18}
Student{name='ace', age=17}
Student{name='jack', age=16}
Student{name='abc', age=16}
Student{name='mark', age=16}

如果想要规则更多一些，可以参考下面代码：

Collections.sort(list, new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
       // 年龄降序
    int result = o2.getAge()-o1.getAge();//年龄降序

    if(result==0){//第一个规则判断完了 下一个规则 姓名的首字母 升序
     result = o1.getName().charAt(0)-o2.getName().charAt(0);
    }
     return result;
  }
});

Student{name='rose', age=18}
Student{name='ace', age=17}
Student{name='abc', age=16}
Student{name='jack', age=16}
Student{name='mark', age=16}

Map集合

java.util.Map接口

Collection接口定义了单列集合规范每次存储一个元素单个元素
Map接口定义了双列集合的规范每次存储一对儿元素(Key Value)

Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
Collection中的集合称为单列集合，Map中的集合称为双列集合。
需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

HashMap<K,V>:存储数据采用的哈希表结构，元素的存取顺序不能保持一致，由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法

LinkedHashMap<K,V>: HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

public V put(K key, V value):把指定的键与指定的值添加到Map集合中
public V remove(Object key):把指定的键所对应的键值对元素 在Map集合中删除，返回被删除元素的值
public V get(Object key):根据指定的键，在Map集合中获取对应的值
boolean containsKey(Object key) 判断集合中是否包含指定的键。
public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)
    
使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中； 
若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

Map集合遍历键找值方式

键找值方式：即通过元素中的键，获取键所对应的值

分析步骤：

获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法: keyset()
遍历键的Set集合，得到每一个键
根据键，获取键所对应的值。方法: get(K key)

public static void main(String[] args) {
        HashMap<String,String> map = new HashMap<String,String>();
        map.put("胡歌", "霍建华");
        map.put("郭德纲", "于谦");
        map.put("薛之谦", "大张伟");
        Set<String> keys = map.keySet();
        for (String key : keys){
            String value = map.get(key);
            System.out.println(key+" "+value);
        }
    }

Map集合遍历键值对方式

键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

操作步骤与图解：

获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:entrySet()。
遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
通过键值对(Entry)对象，获取Entry对象中的键与值。方法提示:getkey() getValue()

public static void main(String[] args) {
        // 创建Map集合对象 
        HashMap<String, String> map = new HashMap<String,String>();
        // 添加元素到集合 
        map.put("胡歌", "霍建华");
        map.put("郭德纲", "于谦");
        map.put("薛之谦", "大张伟");

        // 获取 所有的 entry对象  entrySet
        Set<Entry<String,String>> entrySet = map.entrySet();

        // 遍历得到每一个entry对象
        for (Entry<String, String> entry : entrySet) {
               // 解析 
            String key = entry.getKey();
            String value = entry.getValue();  
            System.out.println(key+"的CP是:"+value);
        }
    }

LinkedHashMap

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

 public static void main(String[] args) {
        LinkedHashMap<String,String> map = new LinkedHashMap<String,String>();
        map.put("邓超", "孙俪");
        map.put("李晨", "范冰冰");
        map.put("刘德华", "朱丽倩");
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        for (Map.Entry<String,String> entry : entrySet){
            System.out.println(entry.getKey()+entry.getValue());
        }
    }

Map集合练习

需求：

计算一个字符串中每个字符出现次数。

分析：

获取一个字符串对象
创建一个Map集合，键代表字符，值代表次数。
遍历字符串得到每个字符。
判断Map中是否有该键。
如果没有，第一次出现，存储次数为1；如果有，则说明已经出现过，获取到对应的值进行++，再次存储。
打印最终结果

public static void main(String[] args) {
        //友情提示
        System.out.println("请录入一个字符串:");
        String line = new Scanner(System.in).nextLine();
        // 定义 每个字符出现次数的方法
        findChar(line);
    }
    private static void findChar(String line) {
        //1:创建一个集合 存储  字符 以及其出现的次数
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
        //2:遍历字符串
        for (int i = 0; i < line.length(); i++) {
            char c = line.charAt(i);
            //判断 该字符 是否在键集中
            if (!map.containsKey(c)) {//说明这个字符没有出现过
                //那就是第一次
                map.put(c, 1);
            } else {
                //先获取之前的次数
                Integer count = map.get(c);
                //count++;
                //再次存入  更新
                map.put(c, ++count);
            }
        }
        System.out.println(map);
    }

JDK9对集合添加的优化

Java 9，添加了几种集合工厂方法,更方便创建少量元素的集合、map实例。新的List、Set、Map的静态工厂方法可以更方便地创建集合的不可变实例。

public class HelloJDK9 {  
    public static void main(String[] args) {  
        Set<String> str1=Set.of("a","b","c");  
        //str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变的集合  
        System.out.println(str1);  
        Map<String,Integer> str2=Map.of("a",1,"b",2);  
        System.out.println(str2);  
        List<String> str3=List.of("a","b");  
        System.out.println(str3);  
    }  
} 

1: of()方法只是Map，List，Set这三个接口的静态方法，其父类接口和子类实现并没有这类方法，比如    HashSet，ArrayList等待；
2: 返回的集合是不可变的；

模拟斗地主洗牌发牌

案例规则

组装54张扑克牌将
54张牌顺序打乱
三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
查看三人各自手中的牌（按照牌的大小排序）、底牌

规则：手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3

案例需求分析

准备牌：

完成数字与纸牌的映射关系：

使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。

洗牌：

通过数字完成洗牌发牌

发牌：

将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。

存放的过程中要求数字大小与斗地主规则的大小对应。

将代表不同纸牌的数字分配给不同的玩家与底牌。

看牌：

通过Map集合找到对应字符展示。

通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示

public static void main(String[] args) {
        /*
         * 1组装54张扑克牌
         */
        // 1.1 创建Map集合存储
        HashMap<Integer, String> pokerMap = new HashMap<Integer, String>();
        // 1.2 创建 花色集合 与 数字集合
        ArrayList<String> colors = new ArrayList<String>();
        ArrayList<String> numbers = new ArrayList<String>();

        // 1.3 存储 花色 与数字
        Collections.addAll(colors, "♦", "♣", "♥", "♠");
        Collections.addAll(numbers, "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
        // 设置 存储编号变量
        int count = 1;
        pokerMap.put(count++, "大王");
        pokerMap.put(count++, "小王");
        // 1.4 创建牌 存储到map集合中
        for (String number : numbers) {
            for (String color : colors) {
                String card = color + number;
                pokerMap.put(count++, card);
            }
        }
        /*
         * 2 将54张牌顺序打乱
         */
        // 取出编号 集合
        Set<Integer> numberSet = pokerMap.keySet();
        // 因为要将编号打乱顺序 所以 应该先进行转换到 list集合中
        ArrayList<Integer> numberList = new ArrayList<Integer>();
        numberList.addAll(numberSet);

        // 打乱顺序
        Collections.shuffle(numberList);

        // 3 完成三个玩家交替摸牌，每人17张牌，最后三张留作底牌
        // 3.1 发牌的编号
        // 创建三个玩家编号集合 和一个 底牌编号集合
        ArrayList<Integer> noP1 = new ArrayList<Integer>();
        ArrayList<Integer> noP2 = new ArrayList<Integer>();
        ArrayList<Integer> noP3 = new ArrayList<Integer>();
        ArrayList<Integer> dipaiNo = new ArrayList<Integer>();

        // 3.2发牌的编号
        for (int i = 0; i < numberList.size(); i++) {
            // 获取该编号
            Integer no = numberList.get(i);
            // 发牌
            // 留出底牌
            if (i >= 51) {
                dipaiNo.add(no);
            } else {
                if (i % 3 == 0) {
                    noP1.add(no);
                } else if (i % 3 == 1) {
                    noP2.add(no);
                } else {
                    noP3.add(no);
                }
            }
        }

        // 4 查看三人各自手中的牌（按照牌的大小排序）、底牌
        // 4.1 对手中编号进行排序
        Collections.sort(noP1);
        Collections.sort(noP2);
        Collections.sort(noP3);
        Collections.sort(dipaiNo);

        // 4.2 进行牌面的转换
        // 创建三个玩家牌面集合 以及底牌牌面集合
        ArrayList<String> player1 = new ArrayList<String>();
        ArrayList<String> player2 = new ArrayList<String>();
        ArrayList<String> player3 = new ArrayList<String>();
        ArrayList<String> dipai = new ArrayList<String>();

        // 4.3转换
        for (Integer i : noP1) {
            // 4.4 根据编号找到 牌面 pokerMap
            String card = pokerMap.get(i);
            // 添加到对应的 牌面集合中
            player1.add(card);
        }

        for (Integer i : noP2) {
            String card = pokerMap.get(i);
            player2.add(card);
        }
        for (Integer i : noP3) {
            String card = pokerMap.get(i);
            player3.add(card);
        }
        for (Integer i : dipaiNo) {
            String card = pokerMap.get(i);
            dipai.add(card);
        }

        //4.5 查看
        System.out.println("令狐冲："+player1);
        System.out.println("石破天："+player2);
        System.out.println("鸠摩智："+player3);
        System.out.println("底牌："+dipai);
    }

异常体系

异常机制其实是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error(工程师不能处理,只能尽量避免)与java.lang.Exception，平常所说的异常指java.lang.Exception(由于使用不当导致,可以避免的)。

Throwable体系：

Error:严重错误Error，无法通过处理的错误，只能事先避免，好比绝症。
Exception:表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好比感冒、阑尾炎。

Throwable中的常用方法：

public void printStackTrace():打印异常的详细信息。

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
public String getMessage():获取发生异常的原因。

提示给用户的时候,就提示错误原因。
public String toString():获取异常的类型和异常描述信息(不用)。

异常的处理

Java异常处理的五个关键字：try、catch、finally、throw、throws

throw new 异常类名(参数)
throw new NullPointerExcerption("要访问的arr数组不存在");
throw new ArrayIndexOutOfBoundsException("该索引所在数组不存在，已超出范围");

如果产生了问题，我们就会throw将问题描述类即异常进行抛出，也就是将问题返回给该方法的调用者。那么对于调用者来说，该怎么处理呢？一种是进行捕获处理，另一种就是继续讲问题声明出去，使用throws声明处理。

public static int getElement(int[] arr, int index){
        if (index < 0 || index > arr.length - 1){
            throw new ArrayIndexOutOfBoundsException("越界");
        }
        int element = arr[index];
        return element;
    }

    public static void main(String[] args) {
        int[] arr = {1,3,6,8,10};
        int index = 5;
        int element = getElement(arr, index);
        System.out.println(element);
    }

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。

关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }

throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

public class ThrowsDemo2 {
    public static void main(String[] args) throws IOException {
        read("a.txt");
    }

    public static void read(String path)throws FileNotFoundException, IOException {
        if (!path.equals("a.txt")) {//如果不是 a.txt这个文件 
            // 我假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw
            throw new FileNotFoundException("文件不存在");
        }
        if (!path.equals("b.txt")) {
            throw new IOException();
        }
    }
}

捕获异常try…catch

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
在方法中使用try-catch的语句块来处理异常。

try-catch的方式就是捕获异常。

捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

try{
    编写可能会出现异常的代码
}catch(异常类型 e){
    处理异常的代码
}
//记录日志/打印异常信息/继续抛出异常

try：该代码块中编写可能产生异常的代码。
catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

注意：try和catch都不能单独使用,必须连用。

public String getMessage():获取异常的描述信息，提示给用户的时候提示错误原因
public String toString():获取异常的类型和异常描述信息
public void printStoackTralce():打印异常的跟踪栈信息并输出到控制台
包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

finally代码块

因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

try…catch….finally:自身需要处理异常,最终还得关闭资源。[注意:finally不能单独使用。]

try{
     编写可能会出现异常的代码
}catch(异常类型A  e){  当try中出现A类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}catch(异常类型B  e){  当try中出现B类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}
注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

运行时异常被抛出可以不处理。即不捕获也不声明抛出。
如果finally有return语句,永远返回finally中的结果,避免该情况.
如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出

自定义异常练习

// 业务逻辑异常
public class RegisterException extends Exception {
    /**
     * 空参构造
     */
    public RegisterException() {
    }

    /**
     *
     * @param message 表示异常提示
     */
    public RegisterException(String message) {
        super(message);
    }
}
====================================================
public class Demo {
    // 模拟数据库中已存在账号
    private static String[] names = {"bill","hill","jill"};
   
    public static void main(String[] args) {     
        //调用方法
        try{
              // 可能出现异常的代码
            checkUsername("nill");
            System.out.println("注册成功");//如果没有异常就是注册成功
        }catch(RegisterException e){
            //处理异常
            e.printStackTrace();
        }
    }

    //判断当前注册账号是否存在
    //因为是编译期异常，又想调用者去处理 所以声明该异常
    public static boolean checkUsername(String uname) throws LoginException{
        for (String name : names) {
            if(name.equals(uname)){//如果名字在这里面 就抛出登陆异常
                throw new RegisterException("亲"+name+"已经被注册了！");
            }
        }
        return true;
    }
}

创建线程类

Java使用java.lang.Thread类代表线程

Java中通过继承Thread类来创建并启动多线程的步骤如下：

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程

public class Demo01 {
    public static void main(String[] args) {
        //创建自定义线程对象
        MyThread mt = new MyThread("新的线程！");
        //开启新线程
        mt.start();
        //在主方法中执行for循环
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程！"+i);
        }
    }
}

自定义线程类

public class MyThread extends Thread {
    //定义指定线程名称的构造方法
    public MyThread(String name) {
        //调用父类的String参数的构造方法，指定线程的名称
        super(name);
    }
    /**
     * 重写run方法，完成该线程执行的逻辑
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"：正在执行！"+i);
        }
    }
}

继承Thread类方式

完成操作过程中用到了java.lang.Thread类

public Thread():分配一个新的线程对象
public Thread(String name):分配一个指定名字的新的线程对象
public Thread(Runnable target):分配一个带有指定目标新的线程对象
public Thread(Runnable target, String name):分配一个带有指定目标新的线程对象并指定名字
    
常用方法：
public String getName():获取当前线程名称
public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法
public void run():此线程要执行的任务在此处定义代码
public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停
public static Thread currentThread():返回对当前正在执行的线程对象的引用

实现Runnable接口方式

采用java.lang.Runnable类，只需要重写run方法即可
步骤如下：
1.定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体
2.创建Runnable实现类的实例，并以此实例为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象
3.调用线程对象的start()方法来启动线程

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
        System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        MyThread mr = new MyThread();
        Thread t = new Thread(mr, "小白");
        t.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("旺财" + i);
        }
    }
}

通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread 对象的start()方法来运行多线程代码。实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现 Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

Thread和Runnable的区别

如果一个类继承Thread, 则不适合资源共享。但是如果实现了Runnable接口的话，则很容易的实现资源共享

实现Runnable接口比继承Thread类所具有的优势：

1.适合多个相同的程序代码的线程去共享同一个资源
2.可以避免java中的单继承的局限性
3.增加程序的健壮性，实现解耦操作，代码额可以被多个线程共享, 代码和线程独立
4.线程池只能放入实现Runnable或Callable类线程，不能直接放入继承Thread的类

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用 java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

线程同时安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

public class Ticket implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while(true){
            if (ticket > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                   e.printStackTrace();
                }
                String name = Thread.currentThread().getName();
                System.out.println(name + ticket--);
            }
        }
    }
}

public class test {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        Thread t1 = new Thread(my,"窗口1 ");
        Thread t2 = new Thread(my,"窗口2 ");
        Thread t3 = new Thread(my,"窗口3 ");
        t1.start();
        t2.start();
        t3.start();
    }
}

怎么使用Java线程同步机制？

1.同步代码块
2.同步方法
3.锁机制

同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问

synchronized(同步锁){
    需要同步操作的代码
}
------------------------------------------------------------------
public void run() {
        while(true){
            synchronized (lock){
                if (ticket > 0){
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    String name = Thread.currentThread().getName();
                    System.out.println(name + ticket--);
                }
            }
       }

同步方法

同步方法：synchronized 修饰的方法, 叫做同步方法. 保证A线程执行该方法的时候, 其他线程只能在方法外等着

同步锁是谁?
对于非static方法,同步锁就是this。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

Lock锁

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了

public class test {
    public static void main(String[] args) {
        MyRunnable my = new MyRunnable();
        Thread t1 = new Thread(my,"窗口1 ");
        Thread t2 = new Thread(my,"窗口2 ");
        Thread t3 = new Thread(my,"窗口3 ");
        t1.start();
        t2.start();
        t3.start();
    }
}
----------------------------------------------
public class MyRunnable implements Runnable{
    private int ticket = 100;
    Lock lock = new ReentrantLock();
     @Override
      public void run() {
        while(true){
            lock.lock();
            if (ticket > 0){
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                String name = Thread.currentThread().getName();
                System.out.println(name + ticket--);
            }
            lock.unlock();
        }
    }
}

线程状态概述

在java.lang.Thread.State这个枚举中给出了六种线程状态：

线程状态	导致状态发生条件
New(新建)	线程刚被创建, 但是并未启动, 还没条用start方法
Runnable(可运行)	线程可以在java虚拟机中运行的状态, 可能正在运行自己代码, 也可能没有, 这取决于操作系统处理器
Blocked(锁阻塞)	当一个线程试图获取一个对象锁, 而该对象锁被其他的线程持有, 则该线程进入Blocked状态; 当该线程持有锁时, 该线程将变成Runnable状态
Waiting(无限等待)	一个线程在等待另一个线程执行一个(唤醒)动作时, 该线程进入Waiting状态。进入这个状态后是不能自动唤醒的, 必须等待另一个线程调用notify或者notifyAll方法才能够唤醒
TimedWaiting(计时终止)	同waiting状态, 有几个方法有超时参数, 调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法又Thread.sleep、Object.wait
Teminated(被终止)	因为run方法正常退出而死亡, 或者没有因为捕获的异常终止了run方法而死亡

一个调用了某个对象的 Object.wait 方法的线程会等待另一个线程调用此对象的 Object.notify()方法或 Object.notifyAll()方法。

其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。就好比在公司里你和你的同事们，你们可能存在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。

当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行）状态中调用了wait()方法那么A线程就进入了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了 notify()方法，那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入 Runnable（可运行）状态；如果没有获取锁对象，那么就进入到Blocked（锁阻塞状态）

public class test {
    public static Object obj = new Object();

    public static void main(String[] args) {
// 演示waiting
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    synchronized (obj) {
                        try {
                            System.out.println(Thread.currentThread().getName() + "=== 获取到锁对象，调用wait方法，进入waiting状态，释放锁对象");
                            obj.wait(); //无限等待
//obj.wait(5000); //计时等待, 5秒 时间到，自动醒来
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "=== 从waiting状态醒来，获取到锁对象，继续执行了");
                    }
                }
            }
        }, "等待线程").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
// while (true){ //每隔3秒 唤醒一次
                try {
                    System.out.println(Thread.currentThread().getName() + "‐‐‐‐‐ 等待3秒钟");
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj) {
                    System.out.println(Thread.currentThread().getName() + "‐‐‐‐‐ 获取到锁对象,调用notify方法，释放锁对象");
                    obj.notify();
                }
            }
// }
        }, "唤醒线程").start();
    }
}

等待唤醒机制

1.wait: 线程不再活动, 不再参与调度, 进入wait set中, 因此不会浪费CPU资源, 也不会去竞争锁, 这时的线程状态即是Waiting。它还要等着别的线程执行一个特别的动作, 也即是”通知(notify)“在这个对象上等待的线程从wait set中释放出来, 重新进入到调度队列(ready queue)中
2.notify: 选取所通知对象的wait set中的一个线程释放：例如, 餐馆有空位置后, 等候就餐最久的顾客最先入座
3.notifyAll: 释放所通知的对象的wait set上的全部线程

哪怕只通知了一个等待的线程, 被通知线程也不能立即恢复执行, 因为它当初终端的地方是在同步块内, 而此刻它偶已经不持有锁, 所以她需要再次尝试去获取锁(可能面临其他线程的竞争), 成功后才能在当初调用wait方法之后的地方恢复执行

如果能获取锁, 线程就从Waiting状态变成Bunnable状态

否则, 从wait set出来, 又进入entry set, 线程就从Waiting状态变成了Blocked状态

调用wait和notify方法需要注意的细节

1.wait方法与notify方法必须由同一锁对象调用因为对应锁对象可以通过notify唤醒使用同一锁对象调用的wait方法后的线程
2.wait方法与notify方法是属于Object类的方法的因为锁对象是可以是任意对象，而任意对象的所属类都是继承了Object类的
3.wait方法与notify方法必须要在同步代码块或者是同步函数中使用因为必须通过锁对象调用这2个方法

void notify():唤醒在此对象监视器上等待的单个线程
void notifyAll():唤醒在此对象监视器上等待的所有线程
void wait():导致当前的线程等待, 直到其他线程调用此对象的notify()方法或者notifyAll()方法
void wait(long timeout):导致当前的线程等待, 直到其他线程调用此对象的notify()方法或notifyAll()方法, 或者指定的时间过完
void wait(long timeout, intik nanos):导致当前的线程等待，直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法，或者其他线程打断了当前线程，或者指定的时间过完。

wait( )，notify( )，notifyAll( )都不属于Thread类，而是属于Object基础类，也就是每个对象都有wait( )，notify( )，notifyAll( ) 的功能，因为每个对象都有锁，锁是每个对象的基础，当然操作锁的方法也是最基础了。
当需要调用以上的方法的时候，一定要对竞争资源进行加锁，如果不加锁的话，则会报 IllegalMonitorStateException 异常
当想要调用wait( )进行线程等待时，必须要取得这个锁对象的控制权（对象监视器），一般是放到synchronized(obj)代码中。
在while循环里而不是if语句下使用wait，这样，会在线程暂停恢复后都检查wait的条件，并在条件实际上并未改变的情况下处理唤醒通知
调用obj.wait( )释放了obj的锁，否则其他线程也无法获得obj的锁，也就无法在synchronized(obj){ obj.notify() } 代码段内唤醒A。
notify( )方法只会通知等待队列中的第一个相关线程（不会通知优先级比较高的线程）
notifyAll( )通知所有等待该竞争资源的线程（也不会按照线程的优先级来执行）
假设有三个线程执行了obj.wait()，那么obj.notifyAll()则能全部唤醒thread1，thread2，thread3，但是要继续执行obj.wait()的下一条语句，必须获取obj锁，因此，thread1，thread2，thread3只有一个有机会获得锁继续执行，例如tread1，其余的需要等待thread1释放obj锁之后才能继续执行。
当调用obj.notify/notifyAll后，调用线程依旧持有obj锁，因此，thread1，thread2，thread3虽被唤醒，但是仍无法获得obj锁。直到调用线程退出synchronized块，释放obj锁后，thread1，thread2，thread3中的一个才有机会获得锁继续执行

线程池

Java里面线程池的顶级接口是java.util.concurrent.Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService

Executoturs类中有个创建线程池的方法：
public static ExecutorService nweFixedThreadPool(int nThreads):返回线程池对象(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：
public Future<?> submit(Runnable task):获取线程池中的某一个线程对象并执行
Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建于使用

使用线程池中线程对象的步骤：

创建线程池对象。

创建Runnable接口子类对象。(task)

提交Runnable接口子类对象。(take task)

关闭线程池(一般不做)。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("我要一个教练");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("教练来了： " + Thread.currentThread().getName());
        System.out.println("教我游泳,交完后，教练回到了游泳池");
    }
}
==========================================================
public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 创建线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
        // 创建Runnable实例对象
        MyRunnable r = new MyRunnable();

        //自己创建线程对象的方式
        // Thread t = new Thread(r);
        // t.start(); ---> 调用MyRunnable中的run()

        // 从线程池中获取线程对象,然后调用MyRunnable中的run()
        service.submit(r);
        // 再获取个线程对象，调用MyRunnable中的run()
        service.submit(r);
        service.submit(r);
        // 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。
        // 将使用完的线程又归还到了线程池中
        // 关闭线程池
        //service.shutdown();
    }
}

Lambda表达式

强调做什么，而不是以什么形式做

面向对象的思想:

做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.

函数式编程思想:

只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程

当需要启动一个线程去完成任务时，通常会通过java.lang.Runnable接口来定义任务内容，并使用java.lang.Thread类来启动该线程。代码如下：

public class Demo01Runnable {
    public static void main(String[] args) {
        // 匿名内部类
        Runnable task = new Runnable() {
            @Override
            public void run() { // 覆盖重写抽象方法
                System.out.println("多线程任务执行！");
            }
        };
        new Thread(task).start(); // 启动线程
    }
}

本着“一切皆对象”的思想，这种做法是无可厚非的：首先创建一个Runnable接口的匿名内部类对象来指定任务内容，再将其交给一个线程来启动。

代码分析

对于Runnable的匿名内部类用法，可以分析出几点内容：

Thread类需要Runnable接口作为参数，其中的抽象run方法是用来指定线程任务内容的核心；
为了指定run的方法体，不得不需要Runnable接口的实现类；
为了省去定义一个RunnableImpl实现类的麻烦，不得不使用匿名内部类；
必须覆盖重写抽象run方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
而实际上，似乎只有方法体才是关键所在。

上述Runnable接口的匿名内部类写法可以通过更简单的Lambda表达式达到等效：

public class Demo02LambdaRunnable {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("多线程任务执行！")).start(); // 启动线程
    }
}

传统代码

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println("多线程任务执行！");
    }
}

public class Demo03ThreadInitParam {
    public static void main(String[] args) {
        Runnable task = new RunnableImpl();
        new Thread(task).start();
    }
}

使用匿名内部类

匿名内部类的好处与弊端
一方面，匿名内部类可以帮我们省去实现类的定义；另一方面，匿名内部类的语法——确实太复杂了！

public class Demo04ThreadNameless {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程任务执行！");
            }
        }).start();
    }
}

即制定了一种做事情的方案（其实就是一个函数）：

无参数：不需要任何条件即可执行该方案。
无返回值：该方案不产生任何结果。
代码块（方法体）：该方案的具体执行步骤。

同样的语义体现在Lambda语法中，要更加简单：

() -> System.out.println("多线程任务执行！")

前面的一对小括号即run方法的参数（无），代表不需要任何条件；
中间的一个箭头代表将前面的参数传递给后面的代码；
后面的输出语句即业务逻辑代码。

Lambda标准格式

Lambda省去面向对象的条条框框，格式由3个部分组成：

一些参数
一个箭头
一段代码

Lambda表达式的标准格式为：

(参数类型 参数名称) -> { 代码语句 }

格式说明：

小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
->是新引入的语法格式，代表指向动作。
大括号内的语法与传统方法体要求基本一致。

Lambda的参数和返回值

需求:
使用数组存储多个Person对象
对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序

当需要对一个对象数组进行排序时，Arrays.sort方法需要一个Comparator接口实例来指定排序的规则。假设有一个Person类，含有String name和int age两个成员变量：

public class Person { 
    private String name;
    private int age;
    
    // 省略构造器、toString方法与Getter Setter 
}

import java.util.Arrays;
import java.util.Comparator;
public class Demo06Comparator {
    public static void main(String[] args) {
          // 本来年龄乱序的对象数组
        Person[] array = {
            new Person("古力娜扎", 19),
            new Person("迪丽热巴", 18),
               new Person("马尔扎哈", 20) };

          // 匿名内部类
        Comparator<Person> comp = new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        };
        Arrays.sort(array, comp); // 第二个参数为排序规则，即Comparator接口实例

        for (Person person : array) {
            System.out.println(person);
        }
    }
}

这种做法在面向对象的思想中，似乎也是“理所当然”的。其中Comparator接口的实例（使用了匿名内部类）代表了“按照年龄从小到大”的排序规则。

代码分析

下面我们来搞清楚上述代码真正要做什么事情。

为了排序，Arrays.sort方法需要排序规则，即Comparator接口的实例，抽象方法compare是关键；
为了指定compare的方法体，不得不需要Comparator接口的实现类；
为了省去定义一个ComparatorImpl实现类的麻烦，不得不使用匿名内部类；
必须覆盖重写抽象compare方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
实际上，只有参数和方法体才是关键。

Lambda写法

import java.util.Arrays;

public class Demo07ComparatorLambda {
    public static void main(String[] args) {
        Person[] array = {
              new Person("古力娜扎", 19),
              new Person("迪丽热巴", 18),
              new Person("马尔扎哈", 20) };

        Arrays.sort(array, (Person a, Person b) -> {
              return a.getAge() - b.getAge();
        });

        for (Person person : array) {
            System.out.println(person);
        }
    }
}

省略规则

在Lambda标准格式的基础上，使用省略写法的规则为：

小括号内参数的类型可以省略；
如果小括号内有且仅有一个参，则小括号可以省略；
如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

备注：掌握这些省略规则后，请对应地回顾本章开头的多线程案例。

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
使用Lambda必须具有上下文推断。
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

备注：有且仅有一个抽象方法的接口，称为“函数式接口”。

File类

public File(String pathname):通过将给定的路径名字字符串转化为抽象路径名来创建新的File实例
public File(String parent, String child):从父路径名字符串和子路径名字符串创建新的File实例
public File(File parent, String child):从父抽象路径名和子路径名字符串创建新的File实例

// 文件路径名
String pathname = "D:\\aaa.txt";
File file1 = new File(pathname); 

// 文件路径名
String pathname2 = "D:\\aaa\\bbb.txt";
File file2 = new File(pathname2); 

// 通过父路径和子路径字符串
 String parent = "d:\\aaa";
 String child = "bbb.txt";
 File file3 = new File(parent, child);

// 通过父级File对象和子路径字符串
File parentDir = new File("d:\\aaa");
String child = "bbb.txt";
File file4 = new File(parentDir, child);

小贴士：
1. 一个File对象代表硬盘中实际存在的一个文件或者目录。
2. 无论该路径下是否存在文件或者目录，都不影响File对象的创建。

常用方法

public String getAbsolutePath():返回此File的绝对路径名字符串
public String getPath():将此File转换为路径名字符串
public String getName():返回由此File表示的文件或目录的名称
public long length():返回由此File表示的文件的长度

public class FileGet {
    public static void main(String[] args) {
        File f = new File("d:/aaa/bbb.java");     
        System.out.println("文件绝对路径:"+f.getAbsolutePath());
        System.out.println("文件构造路径:"+f.getPath());
        System.out.println("文件名称:"+f.getName());
        System.out.println("文件长度:"+f.length()+"字节");

        File f2 = new File("d:/aaa");     
        System.out.println("目录绝对路径:"+f2.getAbsolutePath());
        System.out.println("目录构造路径:"+f2.getPath());
        System.out.println("目录名称:"+f2.getName());
        System.out.println("目录长度:"+f2.length());
    }
}
输出结果：
文件绝对路径:d:\aaa\bbb.java
文件构造路径:d:\aaa\bbb.java
文件名称:bbb.java
文件长度:636字节

目录绝对路径:d:\aaa
目录构造路径:d:\aaa
目录名称:aaa
目录长度:4096
API中说明：length()，表示文件的长度。但是File对象表示目录，则返回值未指定。

绝对路径和相对路径

绝对路径：从盘符开始的路径，这是一个完整的路径。
相对路径：相对于项目目录的路径，这是一个便捷的路径，开发中经常使用。

public class FilePath {
    public static void main(String[] args) {
          // D盘下的bbb.java文件
        File f = new File("D:\\bbb.java");
        System.out.println(f.getAbsolutePath());
          
        // 项目下的bbb.java文件
        File f2 = new File("bbb.java");
        System.out.println(f2.getAbsolutePath());
    }
}
输出结果：
D:\bbb.java
D:\idea_project_test4\bbb.java

判断功能的方法

public boolean exists():此File表示的文件或目录是否真实存在
public boolean isDirectory():此File表示的是否为目录
public boolean isFile():此File表示的是否为文件

创建删除功能的方法

public boolean createNewFile():当且仅当具有该名称的文件尚不存在时候,创建一个新的空文件
public boolean delete():删除由此File表示的文件或目录
public boolean mkdir():创建由此File表示的目录
public boolean mkdirs():创建由此File表示的目录,包括任何必须旦不存在的父目录

public class FileCreateDelete {
    public static void main(String[] args) throws IOException {
        // 文件的创建
        File f = new File("aaa.txt");
        System.out.println("是否存在:"+f.exists()); // false
        System.out.println("是否创建:"+f.createNewFile()); // true
        System.out.println("是否存在:"+f.exists()); // true
        
         // 目录的创建
          File f2= new File("newDir");    
        System.out.println("是否存在:"+f2.exists());// false
        System.out.println("是否创建:"+f2.mkdir());    // true
        System.out.println("是否存在:"+f2.exists());// true

        // 创建多级目录
          File f3= new File("newDira\\newDirb");
        System.out.println(f3.mkdir());// false
        File f4= new File("newDira\\newDirb");
        System.out.println(f4.mkdirs());// true
      
          // 文件的删除
           System.out.println(f.delete());// true
      
          // 目录的删除
        System.out.println(f2.delete());// true
        System.out.println(f4.delete());// false
    }
}
API中说明：delete方法，如果此File表示目录，则目录必须为空才能删除。

目录的遍历

public String[] list():返回一个String数组,表示该FIle目录中的所有子文件或目录
public File[] listFiles():返回一个File数组,表示该FIle目录中的所有的子文件或目录

public class FileFor {
    public static void main(String[] args) {
        File dir = new File("d:\\java_code");
      
          //获取当前目录下的文件以及文件夹的名称。
        String[] names = dir.list();
        for(String name : names){
            System.out.println(name);
        }
        //获取当前目录下的文件以及文件夹对象，只要拿到了文件对象，那么就可以获取更多信息
        File[] files = dir.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    } //打印全文件地址名称

递归

递归打印多级目录

分析：多级目录的打印，就是当目录的嵌套。遍历之前，无从知道到底有多少级目录，所以我们还是要使用递归实现。

代码实现：

public class DiGuiDemo2 {
    public static void main(String[] args) {
          // 创建File对象
        File dir  = new File("D:\\aaa");
          // 调用打印目录方法
        printDir(dir);
    }

    public static void  printDir(File dir) {
          // 获取子文件和目录
        File[] files = dir.listFiles();
          // 循环打印
          /*
            判断:
            当是文件时,打印绝对路径.
            当是目录时,继续调用打印目录的方法,形成递归调用.
          */
        for (File file : files) {
            // 判断
            if (file.isFile()) {
                  // 是文件,输出文件绝对路径
                System.out.println("文件名:"+ file.getAbsolutePath());
            } else {
                  // 是目录,输出目录绝对路径
                System.out.println("目录:"+file.getAbsolutePath());
                  // 继续遍历,调用printDir,形成递归
                printDir(file);
            }
        }
    }
}

文件搜索案例

搜索D:\aaa 目录中的.java 文件。

分析：

目录搜索，无法判断多少级目录，所以使用递归，遍历所有目录。
遍历目录时，获取的子文件，通过文件名称，判断是否符合条件。

代码实现：

public class test {
    public static void main(String[] args) {
        File file = new File("D:\\NotePad++");
        printFile(file);
    }
    public static void printFile(File file){
        File[] files = file.listFiles();
        for (File f1 : files){
            if (f1.isFile()){
                if (f1.getName().endsWith(".xml")){
                    System.out.println("文件名："+f1.getAbsolutePath());
                }
            }else {
                printFile(f1);
            }
        }
    }
}

文件过滤器优化

java.io.FileFilter是一个接口，是File的过滤器。该接口的对象可以传递给File类的 listFiles(FileFilter) 作为参数，接口中只有一个方法。

boolean accept(File pathname)：测试pathname是否应该包含在当前File目录中，符合则返回true。

分析：

接口作为参数，需要传递子类对象，重写其中方法。我们选择匿名内部类方式，比较简单。
accept方法，参数为File，表示当前File下所有的子文件和子目录。保留住则返回true，过滤掉则返回false。保留规则：
1. 要么是.java文件。
2. 要么是目录，用于继续遍历。
通过过滤器的作用，listFiles(FileFilter)返回的数组元素中，子文件对象都是符合条件的，可以直接打印。

代码实现：

public class DiGuiDemo4 {
    public static void main(String[] args) {
        File dir = new File("D:\\aaa");
        printDir2(dir);
    }
  
    public static void printDir2(File dir) {
          // 匿名内部类方式,创建过滤器子类对象
        File[] files = dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.getName().endsWith(".java")||pathname.isDirectory();
            }   //public boolean isDirectory():此File表示的是否为目录
        });
          // 循环打印
        for (File file : files) {
            if (file.isFile()) {
                System.out.println("文件名:" + file.getAbsolutePath());
            } else {
                printDir2(file);
            }
        }
    }
}

Lambda优化

分析：FileFilter是只有一个方法的接口，因此可以用lambda表达式简写。

lambda格式：

()->{ }

代码实现：

public static void printDir3(File dir) {
      // lambda的改写
    File[] files = dir.listFiles(f ->{ 
          return f.getName().endsWith(".java") || f.isDirectory(); 
    });
      
    // 循环打印
    for (File file : files) {
        if (file.isFile()) {
            System.out.println("文件名:" + file.getAbsolutePath());
          } else {
            printDir3(file);
          }
    }
}

字节流、字符流

顶级父类们

	输入流	输出流
字节流	字节输入流 InputStream	字节输出流 OutputStream
字符流	字符输入流 Reader	字符输出流 Writer

字节输出流 OutputStream类

java.io.OutputStream 抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

public void close():关闭此输出流并释放与此流相关联的任何系统资源
public void flush():刷新此输出流并强制任何缓冲的输出字节被写出
public void write(byte[] b):将b.length字节从指定的字节数组写入此输出流
public void write(byte[] b, in off, int len):从指定的字节数组写入len字节,从偏移量off开始输出到此输出流
public abstract void write(int b):将指定的字节输出流
// close方法，当完成流的操作时，必须调用此方法，释放系统资源。

字节输出流 FileOutputStream类

OutputStream有很多子类，我们从最简单的一个子类开始。
java.io.FileOutputStream 类是文件输出流，用于**将数据写出到文件**。

public FileOutputStream(File file):创建文件输出流以写入由指定的File对象表示的文件
public FileOutputStream(String name):创建文件输出流以指定的名称写入文件

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

public class FileOutputStreamConstructor throws IOException {
    public static void main(String[] args) {
           // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("D:\Clash\a.txt");
        // 普通创建
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
    }
}

写出字节数据

写出字节：write(int b) 方法，每次可以写出一个字节数据，代码使用演示：

public static void main(String[] args) throws IOException {
    FileOutputStream fos = new FileOutputStream("D:\\Clash\\a.txt");
    fos.write(97); //a
    fos.close();
}
// 1. 虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
// 2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。

写出字节数组：write(byte[] b)，每次可以写出数组中的数据，代码使用演示：

public static void main(String[] args) throws IOException {
    FileOutputStream fos = new FileOutputStream("D:\\clash\\a.txt");
    yte[] b = "黑马程序员".getBytes();
    fos.write(b);
    fos.close();
}

数据追加续写

经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？

public FileOutputStream(File file, boolean append):创建文件输出流以写入由指定的File对象表示的文件
public FileOutputStream(String name, boolean append):创建文件输出流以指定的名称写入文件

这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：

public static void main(String[] args) throws IOException {
    FileOutputStream fos = new FileOutputStream("D:\\Clash\\a.txt", true);
    byte[] b = "abcde".getBytes();
    fos.write(b);
    fos.close();
}

回车符\r和换行符\n ：
- 回车符：回到一行的开头（return）。
- 换行符：下一行（newline）。
系统中的换行：
- Windows系统里，每行结尾是 回车+换行 ，即\r\n；
- Unix系统里，每行结尾只有 换行 ，即\n；
- Mac系统里，每行结尾是 回车 ，即\r。从 Mac OS X开始与Linux统一。

字节输入流InputStream

java.io.InputStream 抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

public void close():关闭此输入流并释放与此流相关的任何系统资源
public abstract int read():从输入流读取数据的下一个字节
public int read(byte[] b):从输入流中读取一些字节数,并把它们存储到字节数组b中
close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileInputStream类

java.io.FileInputStream 类是文件输入流，从文件中读取字节。

构造方法

FileInputStream(File file):通过打开与实际文件的链接来创建一个FileInputStream，该文件由文件系统中的File对象 file命名
FileInputStream(String name):通过打开与实际文件的链接来创建一个FileInputStream，该文件由文件系统中的路径名 name命名。  
当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException 。

读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1，代码使用演示：

public static void main(String[] args) throws IOException {
   FileInputStream fis = new FileInputStream("D:\\Clash\\a.txt");
   int b;
   while((b=fis.read())!= -1){
      System.out.println((char)b);
   }
    fis.close();
}
//1. 虽然读取了一个字节，但是会自动提升为int类型。
//2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。

使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1 ，代码使用演示：

public static void main(String[] args) throws IOException {
    FileInputStream fis = new FileInputStream("D:\\Clash\\a.txt");
    int len;
    byte[] b = new byte[2];
    while((len = fis.read(b)) != -1){
         System.out.println(new String(b,0,len));
    }
    fis.close();
 }

实现资源的复制

public static void main(String[] args) throws IOException {
    // 1.创建流对象
    // 1.1 指定数据源
    FileInputStream fis = new FileInputStream("D:\\Clash\\a.txt");
    // 1.2 指定目的地
    FileOutputStream fos = new FileOutputStream("D:\\7-Zip\\c.txt");
    // 2.读写数据
    // 2.1 定义数组
    byte[] b = new byte[1024];
    // 2.2 定义长度
    int len;
    // 2.3 循环读取
    while((len = fis.read(b))!=-1){
    // 2.4 写出数据
        fos.write(b,0,len);
    }
    // 3.关闭资源
    fos.close();
    fis.close();
}
// 流的关闭原则：先开后关，后开先关。

FileReader类

FileReader(File file):创建一个新的FileReader，给定要读取的File对象
FileReader(String fileName):创建一个新的FileReader，给定要读取的文件的名称

public static void main(String[] args) throws IOException {
    FileReader fr = new FileReader("D:\\Clash\\a.txt");
    int len;
    char[] cbuf = new char[1024];
    while((len = fr.read(cbuf))!=-1){
        System.out.println(new String(cbuf,0,len));
    }
    fr.close();
}

字符输出流Writer

java.io.Writer 抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

void write(int c):写入单个字符
void write(char[] cbuf):写入字符数组
abstract void weite(char[] cbuf, int off, int len):写入字符数组的某一部分,off数组的开始索引,len写的字符个数
void write(String str):写入字符串
void write(String str, int off, int len):写入字符串的某一部分,off字符串的开始索引,len写的字符个数
void flush():刷新该流的缓冲
void close():关闭此流,但要先刷新它

FileWriter类

java.io.FileWriter 类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

FileWriter(File file):创建一个新的FileWriter,给定要读取的File对象
FileWeiter(String fileName):创建一个新的FileWeiter,给定要读取的文件的名称

public static void main(String[] args) throws IOException {
            // 使用File对象创建流对象
        File file = new File("a.txt");
        FileWriter fw = new FileWriter(file);
      
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("b.txt");
    }
}

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。

flush ：刷新缓冲区，流对象可以继续使用。
close :先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

即便是flush方法写出了数据，操作的最后还是要调用close方法，释放系统资源。

写出其他数据

写出字符数组 ：write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据，用法类似FileOutputStream

写出字符串：write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据，更为方便

续写和换行：操作类似于FileOutputStream。

字符流，只能操作文本文件，不能操作图片，视频等非文本文件。当我们单纯读或者写文本文件时使用字符流其他情况使用字节流

字符：是指计算机中使用的字母、数字、字和符号，包括：1、2、3、A、B、C、~！·#￥%……—*（）——+等等。在ASCII编码中，一个英文字母字符存储需要1个字节。

字节：计算机存储容量基本单位是字节（Byte），音译为拜特，8个二进制位组成1个字节，一个标准英文字母占一个字节位置，一个标准汉字占二个字节位置。计算机存储容量大小以字节数来度量。

异常的处理(回顾)

之前的入门练习，我们一直把异常抛出，而实际开发中并不能这样处理，建议使用try...catch...finally 代码块，处理异常部分，代码使用演示：

public static void main(String[] args) throws IOException {
        FileWriter fw = null;
        try {
            fw = new FileWriter("D:\\Clash\\a.txt");
            fw.write("黑马程序员");
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if (fw != null){
                    fw.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }

try (创建流对象语句，如果多个,使用’;’隔开) {
// 读写数据
} catch (IOException e) {
e.printStackTrace();
}

public class HandleException2 {
    public static void main(String[] args) {
          // 创建流对象
        try ( FileWriter fw = new FileWriter("fw.txt"); ) {
            // 写出数据
            fw.write("黑马程序员"); //黑马程序员
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JDK9中try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close，我们来了解一下格式。

public class TryDemo {
    public static void main(String[] args) throws IOException {
           // 创建流对象
        final  FileReader fr  = new FileReader("in.txt");
        FileWriter fw = new FileWriter("out.txt");
           // 引入到try中
        try (fr; fw) {
              // 定义变量
            int b;
              // 读取数据
              while ((b = fr.read())!=-1) {
                // 写出数据
                fw.write(b);
              }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Properties类

构造方法

public Properties() :创建一个空的属性列表。

基本的存储方法

public Object setProperty(String key, String value):保存一对属性
public String getProperty(String key):使用此属性列表中指定的键搜索属性值
public Set<String> stringPropertyNames():所有键的名称的集合

public class ProDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 创建属性集对象
        Properties properties = new Properties();
        // 添加键值对元素
        properties.setProperty("filename", "a.txt");
        properties.setProperty("length", "209385038");
        properties.setProperty("location", "D:\\a.txt");
        // 打印属性集对象
        System.out.println(properties);
        // 通过键,获取属性值
        System.out.println(properties.getProperty("filename"));
        System.out.println(properties.getProperty("length"));
        System.out.println(properties.getProperty("location"));

        // 遍历属性集,获取所有键的集合
        Set<String> strings = properties.stringPropertyNames();
        // 打印键值对
        for (String key : strings ) {
              System.out.println(key+" -- "+properties.getProperty(key));
        }
    }
}
输出结果：
{filename=a.txt, length=209385038, location=D:\a.txt}
a.txt
209385038
D:\a.txt
filename -- a.txt
length -- 209385038
location -- D:\a.txt

与流相关的方法

public void load(InputStream inStream):从字节输入流中读取键值对

参数中使用了字节输入流，通过流对象，可以关联到某文件上，这样就能够加载文本中的数据了。文本数据格式:

filename=a.txt
length=209385038
location=D:\a.txt

加载代码演示：

public class ProDemo2 {
    public static void main(String[] args) throws FileNotFoundException {
        // 创建属性集对象
        Properties pro = new Properties();
        // 加载文本中信息到属性集
        pro.load(new FileInputStream("read.txt"));
        // 遍历集合并打印
        Set<String> strings = pro.stringPropertyNames();
        for (String key : strings ) {
              System.out.println(key+" -- "+pro.getProperty(key));
        }
     }
}
输出结果：
filename -- a.txt
length -- 209385038
location -- D:\a.txt

小贴士：文本中的数据，必须是键值对形式，可以使用空格、等号、冒号等符号分隔。

缓冲流

字节缓冲流 BufferedInputStream, BufferedOutputStream
字符缓冲流 BufferedReader, BudfferedWeiter

字节缓冲流

public BufferedInputStream(InputStream in):创建一个新的缓冲输入流
public BufferedOutputStream(OutputStream out):创建一个新的缓冲输出流

// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

public static void main(String[] args) throws FileNotFoundException {
          // 记录开始时间
        long start = System.currentTimeMillis();
        // 创建流对象
        try (
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
        ){
              // 读写数据
            int len;
            byte[] bytes = new byte[8*1024];
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0 , len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("缓冲流使用数组复制时间:"+(end - start)+" 毫秒");
    }
缓冲流使用数组复制时间:666 毫秒

字符缓冲流

public BufferedReader(Reader in):创建一个新的缓冲输入流
public BufferedReader(Writer out):创建一个新的缓冲输出流

字节(Byte) 是计量单位，表示数据量多少，是计算机信息技术用于计量存储容量的一种计量单位，通常情况下一字节等于八位。
**字符(Character) ** 是计算机中使用的字母、数字、字和符号，比如’A’、’B’、’$’、’&’等。

特有方法

BufferedReader：public String readLine():读一行文字
bufferedWeiter：public void newLine():写一行行分隔符，由系统属性定义符号

readLine代码展示
public static void main(String[] args) throws IOException {
           // 创建流对象
        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
        // 定义字符串,保存读取的一行文字
        String line  = null;
          // 循环读取,读取到最后返回null
        while ((line = br.readLine())!=null) {
            System.out.print(line);
            System.out.println("------");
        }
        // 释放资源
        br.close();
    }

newLine代码展示
public static void main(String[] args) throws IOException  {
          // 创建流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
          // 写出数据
        bw.write("黑马");
          // 写出换行
        bw.newLine();
        bw.write("程序");
        bw.newLine();
        bw.write("员");
        bw.newLine();
        // 释放资源
        bw.close();
    }
}
输出效果:
黑马
程序
员

练习: 文本排序

请将文本信息恢复顺序。

3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。
8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
4.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
2.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。
9.今当远离，临表涕零，不知所言。
6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
5.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。

案例分析

逐行读取文本信息。
解析文本信息到集合中。
遍历集合，按顺序，写出文本信息。

案例实现

 public static void main(String[] args) throws IOException {
        // 创建map集合,保存文本数据,键为序号,值为文字
        HashMap<String, String> lineMap = new HashMap<>();

        // 创建流对象
        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));

        // 读取数据
        String line  = null;
        while ((line = br.readLine())!=null) {
            // 解析文本
            String[] split = line.split("\\.");
            // 保存到集合
            lineMap.put(split[0],split[1]);
        }
        // 释放资源
        br.close();

        // 遍历map集合
        for (int i = 1; i <= lineMap.size(); i++) {
            String key = String.valueOf(i);
            // 获取map中文本
            String value = lineMap.get(key);
              // 写出拼接文本
            bw.write(key+"."+value);
              // 写出换行
            bw.newLine();
        }
        // 释放资源
        bw.close();
    }

Integer valueOf(int i)：返回一个表示指定的 int 值的 Integer 实例。

**Integer valueOf(String s):**返回保存指定的 String 的值的 Integer 对象。

Integer valueOf(String s, int radix): 返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。

OutputStreamWriter类

转换流java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流
OutputStreamWriter(OutputStream in, String charsetName): 创建一个指定字符集的字符流

OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

public static void main(String[] args) throws IOException {
          // 定义文件路径
        String FileName = "E:\\out.txt";
          // 创建流对象,默认UTF8编码
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
        // 写出数据
          osw.write("你好"); // 保存为6个字节
        osw.close();
        // 定义文件路径
        String FileName2 = "E:\\out2.txt";
         // 创建流对象,指定GBK编码
        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
        // 写出数据
          osw2.write("你好");// 保存为4个字节
        osw2.close();
 }

ObjectOutputStream类

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

构造方法

public ObjectOutputStream(OutputStream out)：创建一个指定OutputStream的ObjectOutputStream。

ObjectInputStream类

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

public ObjectInputStream(InputStream in) ：创建一个指定InputStream的ObjectInputStream。

反序列化操作1

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用ObjectInputStream读取对象的方法：

public final Object readObject () : 读取一个对象。

对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 ClassNotFoundException 异常。
另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException异常。发生这个异常的原因如下：

该类的序列版本号与从流中读取的类描述符的版本号不匹配
该类包含未知数据类型
该类没有可访问的无参数构造方法

Serializable 接口给需要序列化的类，提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

序列化操作

一个对象要想序列化，必须满足两个条件:

该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。
该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

一、是什么
序列化：就是将对象转化成字节序列的过程。

反序列化：就是讲字节序列转化成对象的过程。

对象序列化成的字节序列会包含对象的类型信息、对象的数据等，说白了就是包含了描述这个对象的所有信息，能根据这些信息“复刻”出一个和原来一模一样的对象。

二、为什么
那么为什么要去进行序列化呢？有以下两个原因

持久化：对象是存储在JVM中的堆区的，但是如果JVM停止运行了，对象也不存在了。序列化可以将对象转化成字节序列，可以写进硬盘文件中实现持久化。在新开启的JVM中可以读取字节序列进行反序列化成对象。

网络传输：网络直接传输数据，但是无法直接传输对象，可在传输前序列化，传输完成后反序列化成对象。所以所有可在网络上传输的对象都必须是可序列化的。

三、怎么做
怎么去实现对象的序列化呢？

Java为我们提供了对象序列化的机制，规定了要实现序列化对象的类要满足的条件和实现方法。

对于要序列化对象的类要去实现Serializable接口或者Externalizable接口

实现方法：JDK提供的ObjectOutputStream和ObjectInputStream来实现序列化和反序列化

下面分别实现Serializable和Externalizable接口来演示序列化和反序列化

public class Employee implements java.io.Serializable {
    public String name;
    public String address;
    public transient int age; // transient瞬态修饰成员,不会被序列化
    public void addressCheck() {
          System.out.println("Address  check : " + name + " -- " + address);
    }
}

public final void writeObject (Object obj) : 将指定的对象写出。
    
public class SerializeDemo{
       public static void main(String [] args)   {
        Employee e = new Employee();
        e.name = "zhangsan";
        e.address = "beiqinglu";
        e.age = 20; 
        try {
              // 创建序列化流对象
          ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
            // 写出对象
            out.writeObject(e);
            // 释放资源
            out.close();
            fileOut.close();
            System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。
        } catch(IOException i)   {
            i.printStackTrace();
        }
       }
}
输出结果：
Serialized data is saved

练习：序列化集合

将存有多个自定义对象的集合序列化操作，保存到list.txt文件中。
反序列化list.txt ，并遍历集合，打印对象信息。

案例分析

把若干学生对象，保存到集合中。
把集合序列化。
反序列化读取时，只需要读取一次，转换为集合类型。
遍历集合，可以打印所有的学生信息

案例实现

public class SerTest {
    public static void main(String[] args) throws Exception {
        // 创建 学生对象
        Student student = new Student("老王", "laow");
        Student student2 = new Student("老张", "laoz");
        Student student3 = new Student("老李", "laol");

        ArrayList<Student> arrayList = new ArrayList<>();
        arrayList.add(student);
        arrayList.add(student2);
        arrayList.add(student3);
        // 序列化操作
        // serializ(arrayList);
        
        // 反序列化  
        ObjectInputStream ois  = new ObjectInputStream(new FileInputStream("list.txt"));
        // 读取对象,强转为ArrayList类型
        ArrayList<Student> list  = (ArrayList<Student>)ois.readObject();
        
          for (int i = 0; i < list.size(); i++ ){
              Student s = list.get(i);
            System.out.println(s.getName()+"--"+ s.getPwd());
          }
    }

    private static void serializ(ArrayList<Student> arrayList) throws Exception {
        // 创建 序列化流 
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
        // 写出对象
        oos.writeObject(arrayList);
        // 释放资源
        oos.close();
    }
}

PrintStream类

构造方法

public PrintStream(String fileName) ：使用指定的文件名创建一个新的打印流。

构造举例，代码如下：

PrintStream ps = new PrintStream("ps.txt")；

改变打印流向

System.out就是PrintStream类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象，我们就可以玩一个”小把戏”，改变它的流向。

public class PrintDemo {
    public static void main(String[] args) throws IOException {
        // 调用系统的打印流,控制台直接输出97
        System.out.println(97);
      
        // 创建打印流,指定文件的名称
        PrintStream ps = new PrintStream("ps.txt");
          
          // 设置系统的打印流流向,输出到ps.txt
        System.setOut(ps);
          // 调用系统的打印流,ps.txt中输出97
        System.out.println(97);
    }
}

Socket类

Socket类：该类实现客户端套接字，套接字指的是两台设备之间通讯的端点

构造方法

public Socket(String host, int port):创建套接字对象并将其连接到指定主机上的指定端口号。如果指定的host是null ，则相当于指定地址为回送地址。

小贴士：回送地址(127.x.x.x) 是本机回送地址（Loopback Address），主要用于网络软件测试以及本地机进程间通信，无论什么程序，一旦使用回送地址发送数据，立即返回，不进行任何网络传输。

构造举例，代码如下：

Socket client = new Socket("127.0.0.1", 6666);

成员方法

public InputStream getInputStream() ： 返回此套接字的输入流。
  - 如果此Scoket具有相关联的通道，则生成的InputStream 的所有操作也关联该通道。
  - 关闭生成的InputStream也将关闭相关的Socket。
public OutputStream getOutputStream() ： 返回此套接字的输出流。
  - 如果此Scoket具有相关联的通道，则生成的OutputStream 的所有操作也关联该通道。
  - 关闭生成的OutputStream也将关闭相关的Socket。
public void close() ：关闭此套接字。
  - 一旦一个socket被关闭，它不可再使用。
  - 关闭此socket也将关闭相关的InputStream和OutputStream 。 
public void shutdownOutput() ： 禁用此套接字的输出流。   
  - 任何先前写出的数据将被发送，随后终止输出流。

ServerSocket类

ServerSocket类：这个类实现了服务器套接字，该对象等待通过网络的请求。

构造方法

ServerSocket类：这个类实现了服务器套接字，该对象等待通过网络的请求。
ServerSocket server = new ServerSocket(6666);

成员方法

public Socket accept():侦听并接受链接，返回一个新的Socket对象，用于和客户端实现通信，该方法一直阻塞直到建立链接

客户端向服务器发送数据

服务端实现：

public class ServerTCP {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动 , 等待连接 .... ");
        // 1.创建 ServerSocket对象，绑定端口，开始等待连接
        ServerSocket ss = new ServerSocket(6666);
        // 2.接收连接 accept 方法, 返回 socket 对象.
        Socket server = ss.accept();
        // 3.通过socket 获取输入流
        InputStream is = server.getInputStream();
        // 4.一次性读取数据
          // 4.1 创建字节数组
        byte[] b = new byte[1024];
          // 4.2 据读取到字节数组中.
        int len = is.read(b)；
        // 4.3 解析数组,打印字符串信息
        String msg = new String(b, 0, len);
        System.out.println(msg);
        //5.关闭资源.
        is.close();
        server.close();
    }
}

客户端实现：

public class ClientTCP {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端 发送数据");
        // 1.创建 Socket ( ip , port ) , 确定连接到哪里.
        Socket client = new Socket("localhost", 6666);
        // 2.获取流对象 . 输出流
        OutputStream os = client.getOutputStream();
        // 3.写出数据.
        os.write("你好么? tcp ,我来了".getBytes());
        // 4. 关闭资源 .
        os.close();
        client.close();
    }
}

服务器向客户端回写数据

服务端实现：

public class ServerTCP {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动 , 等待连接 .... ");
        // 1.创建 ServerSocket对象，绑定端口，开始等待连接
        ServerSocket ss = new ServerSocket(6666);
        // 2.接收连接 accept 方法, 返回 socket 对象.
        Socket server = ss.accept();
        // 3.通过socket 获取输入流
        InputStream is = server.getInputStream();
        // 4.一次性读取数据
          // 4.1 创建字节数组
        byte[] b = new byte[1024];
          // 4.2 据读取到字节数组中.
        int len = is.read(b)；
        // 4.3 解析数组,打印字符串信息
        String msg = new String(b, 0, len);
        System.out.println(msg);
          // =================回写数据=======================
          // 5. 通过 socket 获取输出流
           OutputStream out = server.getOutputStream();
          // 6. 回写数据
           out.write("我很好,谢谢你".getBytes());
          // 7.关闭资源.
          out.close();
        is.close();
        server.close();
    }
}

客户端实现：

public class ClientTCP {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端 发送数据");
        // 1.创建 Socket ( ip , port ) , 确定连接到哪里.
        Socket client = new Socket("localhost", 6666);
        // 2.通过Scoket,获取输出流对象 
        OutputStream os = client.getOutputStream();
        // 3.写出数据.
        os.write("你好么? tcp ,我来了".getBytes());
          // ==============解析回写=========================
          // 4. 通过Scoket,获取 输入流对象
          InputStream in = client.getInputStream();
          // 5. 读取数据数据
          byte[] b = new byte[100];
          int len = in.read(b);
          System.out.println(new String(b, 0, len));
        // 6. 关闭资源 .
          in.close();
        os.close();
        client.close();
    }
}

函数式接口

函数式接口在Java中是指：有且仅有一个抽象方法的接口

函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。

修饰符 interface 接口名称 {
    public abstract 返回值类型 方法名称(可选参数信息);
    // 其他非抽象方法内容
}

由于接口当中抽象方法的 public abstract 是可以省略的，所以定义一个函数式接口很简单：

public interface MyFunctionalInterface{
    void myMethod(); //省略public abstract
}

@FunctionalInterface注解

与@Override注解的作用类似，引入了一个新的注解@FunctionalInterface 该注解可用于上一个接口的定义上

@FunctionalInterface
public interface MyfunctionalInterface{
    void myMethod();
}

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

对于刚刚定义好的 MyFunctionalInterface 函数式接口，典型使用场景就是作为方法的参数：

public class Demo09FunctionalInterface{
    //使用自定义的函数式接口方法
    private static void deSomething(MyfunctionalInterfalce inter){
        inter.myMethod(); //调用自定义的函数式接口方法
    }
    
    public static void main(String[] args){
        //调用使用函数式接口的方法
        doSomething(()->System.out,println("Lambda执行啦！"));
    }
}

Lambda的延迟

public static void log(int level, MessageBuilder builder){
        if (level == 1){
            System.out.println(builder.buildMessage());
        }
    }

    public static void main(String[] args){
        String msgA = "Hello";
        String msgB = "world";
        String msgC = "Java";
        log(2,() -> {
            System.out.println("Lambda执行啦！");
            return msgA+msgB+msgC;
        });
    }
}

从结果中可以看出，在不符合级别要求的情况下，Lambda将不会执行。从而达到节省性能的效果。

扩展：实际上使用内部类也可以达到同样的效果，只是将代码操作延迟到了另外一个对象当中通过调用方法来完成。而是否调用其所在方法是在条件判断之后才执行的。

使用Lambda作为参数和返回值

如果抛开实现原理不说，Java中的Lambda表达式可以被当作是匿名内部类的替代品。如果方法的参数是一个函数式接口类型，那么就可以使用Lambda表达式进行替代。使用Lambda表达式作为方法参数，其实就是使用函数式接口作为方法参数。
例如 java.lang.Runnable 接口就是一个函数式接口，假设有一个 startThread 方法使用该接口作为参数，那么就可以使用Lambda进行传参。这种情况其实和 Thread 类的构造方法参数为 Runnable 没有本质区别。

public class DemoRunnable{
    private static void startThread(Runnable task){
        new Thread(task).start();
    }
    public static void main(String[] args){
        startThread(()->System.out.println("线程任务执行！"));
    }
}

类似地，如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。当需要通过一个方法来获取一个 java.util.Comparator 接口类型的对象作为排序器时, 就可以调该方法获取

private static Comparable<String> newComparator(){
    return(a,b) -> b.length() - a.length();
    // 其中直接return一个Lambda表达式即可
}

public static void main(String[] args) {
    String[] array = {"abc","ab","abcd"};
    System.out.println(Arrays.toString(array));
    Arrays.sort(array,newComparator());
    System.out.println(Arrays.toString(array));
}

常用函数式接口

Supplier接口

java.util.function.Supplier<T>接口仅包含一个无参的方法：T get() 用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，也就意味着对应Lambda表达式需要”对外提供“一个符合泛型类型的对象数据

public class Demo08Supplier {
    private static String getString(Supplier<String> function) {
    return function.get();
}
public static void main(String[] args) {
    String msgA = "Hello";
    String msgB = "World";
    System.out.println(getString(() ‐> msgA + msgB));
    }
}

求数组元素最大值

题目

使用 Supplier 接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值。
提示：接口的泛型请使用 java.lang.Integer 类。

解答

public class Demo02Test {
//定一个方法,方法的参数传递Supplier,泛型使用Integer
    public static int getMax(Supplier<Integer> sup){
    return sup.get();
}
public static void main(String[] args) {
    int arr[] = {2,3,4,52,333,23};
    //调用getMax方法,参数传递Lambda
    int maxNum = getMax(()‐>{
    //计算数组的最大值
    int max = arr[0];
    for(int i : arr){
        if(i>max){
     max = i;
     }
    }
     return max;
   });
    System.out.println(maxNum);
    }
}

Consumer接口

java.util.function.Consumer 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。

抽象方法：accept

Consumer接口中包含抽象方法void accept(T t), 意为消费一个指定泛型的数据

private static void consumeString(Consumer<String> function){
    function.accept("Hello!");
}
public static void main(String[] args) {
    consumeString(s -> System.out.println(s));
}

默认方法：andThen

如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。下面是JDK的源代码：

default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return (T t) ‐> { accept(t); after.accept(t); };
}

要想实现组合，需要两个或多个Lambda表达式即可，而 andThen 的语义正是“一步接一步”操作。例如两个步骤组合的情况：

private static void consumeString(Consumer<String> one, Consumer<String>two){
        one.andThen(two).accept("hello");
}

    public static void main(String[] args) {
        consumeString(
                s-> System.out.println(s.toUpperCase()),
                s -> System.out.println(s.toLowerCase())
    );
}
// 运行结果将会首先打印完全大写的HELLO，然后打印完全小写的hello。当然，通过链式写法可以实现更多步骤的组合。

格式化打印信息

题目

下面的字符串数组当中存有多条信息，请按照格式“ 姓名：XX。性别：XX。”的格式将信息打印出来。要求将打印姓名的动作作为第一个 Consumer 接口的Lambda实例，将打印性别的动作作为第二个 Consumer接口的Lambda实例，将两个 Consumer 接口按照顺序“拼接”到一起。

public static void main(String[] args) {
    String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" };
}

解答

import java.util.function.Consumer;
public class test {
    private static void printInfo(Consumer<String>one, Consumer<String>two, String[] array){
        for (String info : array){
        one.andThen(two).accept(info);
        }
    }

    public static void main(String[] args) {
        String[] array = {"迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男"};
        printInfo(s-> System.out.print("姓名:"+s.split(",")[0]),
                  s-> System.out.println("。性别："+s.split(",")[1]+"。"),
                  array
                  );
    }
}

Predicate接口

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用 java.util.function.Predicate 接口。

public class Demo15PredicateTest{
    private static void metho(Predicate<String> predicate){
        boolean veryLong = predicate.test("HelloWorld");
    }
    public static void main(String[] args){
        method(s -> s.length() > 5);
    }
}
// 条件判断的标准是传入的Lambda表达式逻辑，只要字符串长度大于5则认为很长。

默认方法：and

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实现“并且”的效果时，可以使用default方法 and 。其JDK源码为：

defalult Predicate<T> and(Predkicate<? super T> other){
    Object.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
}

如何判断一个字符串既包含大写”H”，又包含大写”W”

public class test {
   private static void method(Predicate<String>one, Predicate<String>two){
       boolean isValid = one.and(two).test("HelloWorld");
       System.out.println("是否符合？"+isValid);
   }

    public static void main(String[] args) {
        method(s -> s.contains("H"), s -> s.contains("o"));
    }
} // 是否符合？true

默认方法：or

defalult Predicate<T> or (Predkicate<? super T> other){
    Object.requireNonNull(other);
    return (t) -> test(t) || other.test(t);
}

如何判断一个字符串既包含大写”H”，又包含大写”W”

public class test {
   private static void method(Predicate<String>one, Predicate<String>two){
       boolean isValid = one.and(two).test("HelloWorld");
       System.out.println("是否符合？"+isValid);
   }

    public static void main(String[] args) {
        method(s -> s.contains("H"), s -> s.contains("o"));
    }
} // 是否符合？true

默认方法：negate (“非”[取反])

default Predicate<T> negate(){
    return (t) -> !test(t);
}

从现实中很容易看出，它是执行了test方法之后，对结果boolean值进行”!”取反而已。一定要在test方法调用之前调用negate方法，正如and和or方法一样

public class Demo17PredicateNegate{
    private static void methodW(Predicate<String> predicate){
        boolean veryLong = predicate.negate().test("HelloWorld");
        System.out.println("字符串很长吗：" + veryLong);
    }
    public static void main(String[] args){
        method(s -> s.length() < 5);
    }
}

集合信息筛选

题目

数组当中有多条“姓名+性别”的信息如下，请通过 Predicate 接口的拼装将符合要求的字符串筛选到集合 ArrayList 中，需要同时满足两个条件：

必须为女生；

姓名为4个字。

public class DemoPredicate {
    public static void main(String[] args) {
        String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
    }
}

解答

 public static void main(String[] args) {
        String[] array = {"迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
        List<String> list = filter(array,
                s -> "女".equals(s.split(",")[1]),
                s -> s.split(",")[0].length() == 4);
        System.out.println(list);
    }
 private static List<String> filter(String[] array, Predicate<String>one, Predicate<String>two){
       List<String> list = new ArrayList<>();
       for (String info : array){
           if (one.and(two).test(info)){
               list.add(info);
           }
       }
       return list;
 }

Stream流高级改造

public static void main(String[] args) {
        String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
        Arrays.stream(array)
                .filter(s -> "女".equals(s.split(",")[1]))
            //  .filter(s -> s.split(",")[1].startsWith("女"))
                .filter(s -> s.split(",")[0].length()==3)
                .forEach(System.out::println);
}

Stream流式思想改造

 public static void main(String[] args) {
        Stream<String>original = Stream.of("迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" );
        Stream<String>result1 = original.filter(s -> s.split(",")[1].startsWith("女"));
        Stream<String>result2 = result1.filter(s -> s.split(",")[0].length()==3);
        result2.forEach(System.out::println);
    }

Function接口

java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者成为后置条件。

抽象方法：apply

apply Function 接口中最主要的抽象方法为：R apply(T t) ，根据类型T的参数获取类型R的结果。使用的场景例如：将 String 类型转换为 Integer 类型。

private static void method(Function<String,Integer> function){
     int num = function.apply("10");
     System.out.println(num + 10);
}

public static void main(String[] args) {
     method(s -> Integer.parseInt(s));
}

默认方法：andThen

Function接口中有一个默认的andThen方法，用来进行组合操作

default <V> Function<T,V> andThen(Function<? super R, ? extends V> after){
    Objects.requireNonNull(after);
    return (T t) -> after.apply(apply(t));
}

该方法同样用于“先做什么，再做什么”的场景，和 Consumer 中的 andThen 差不多：

public class Demo12FunctionAndThen {
    private static void method(Function<String, Integer> one, Function<Integer, Integer> two) {
        int num = one.andThen(two).apply("10");
        System.out.println(num + 20);
}
    public static void main(String[] args) {
        method(str‐>Integer.parseInt(str)+10, i ‐> i *= 10);
    }
}

第一个操作是将字符串解析成为int数字，第二个操作是乘以10。两个操作通过 andThen 按照前后顺序组合到了一起。

private static void method(Function<String, Integer> one, Function<Integer, Integer> two) {
        int num = one.andThen(two).apply("10");
        System.out.println(num + 20);
}
public static void main(String[] args) {
        method(str‐>Integer.parseInt(str)+10, i ‐> i *= 10);
}

第一个操作是将字符串解析成为int数字，第二个操作是乘以10。两个操作通过 andThen 按照前后顺序组合到了一起。

请注意，Function的前置条件泛型和后置条件泛型可以相同。

自定义函数模型拼接

题目

请使用 Function 进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
String str = "赵丽颖,20"

1.将字符串截取数字年龄部分，得到字符串；
2.将上一步的字符串转换成为int类型的数字；
3.将上一步的int数字累加100，得到结果int数字。

解答

private static int getAgeNum(String str, Function<String, String>one, Function<String, Integer>two, Function<Integer, Integer> three){
    return one.andThen(two).andThen(three).apply(str);
}

public static void main(String[] args) {
    String str = "赵丽颖,20";
    int age = getAgeNum(str,
         s -> s.split(",")[1],
         s -> Integer.parseInt(s),
         n -> n += 100);
    System.out.println(age);
}

Stream流、方法引用

说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。

Java 8的Lambda让我们可以更加专注于做什么（What），而不是怎么做（How），这点此前已经结合内部类进行了对比说明。现在，我们仔细体会一下上例代码，可以发现：

for循环的语法就是“怎么做”
for循环的循环体才是“做什么”

为什么使用循环？因为要进行遍历。但循环是遍历的唯一方式吗？遍历是指每一个元素逐一进行处理，而并不是从第一个到最后一个顺次处理的循环。前者是目的，后者是方式。

试想一下，如果希望对集合中的元素进行筛选过滤：
1.将集合A根据条件一过滤为子集B；
2.然后再根据条件二过滤为子集C。

每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？不是。循环是做事情的方式，而不是目的。另一方面，使用线性循环就意味着只能遍历一次。如果希望再次遍历，只能再使用另一个循环从头开始。

Stream更优写法

直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印。代码中并没有体现使用线性循环或是其他任何算法进行遍历，我们真正要做的事情内容被更好地体现在代码中。

public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length()==3).forEach(System.out::println);

    }

“Stream流”其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值)。

Stream(流)是一个来自数据源的元素队列

元素是特定类型的对象，形成一个队列。java中的stream并不会存储元素，而是按需计算
数据源流的来源：可以是集合，数组等

和以前的Collection操作不同， Stream操作还有两个基础的特征：

Pipelining: 中间操作都会返回流对象本身。这样多个操作可以串联成一个管道，如同流式风格（fluent style）。这样做可以对操作进行优化，比如延迟执行(laziness)和短路( short-circuiting)。
内部迭代：以前对集合遍历都是通过Iterator或者增强for的方式，显示的在集合外部进行迭代，这叫做外部迭代。Stream提供了内部迭代的方式，流可以直接调用遍历方法forEach(System.out::println)

当使用一个流的时候，通常包括三个步骤：获取一个数据源(source) → 数据转换 → 执行操作获取想要的结果，每次转换原有Stream对象不改变，返回一个新的Stream对象(可以有多次转换)，这就允许对其操作可以像链条一样排列，变成一个管道

获取流

java.util.stream.Stream<T>是最常用的流接口
获取方式：
**1.**所有的Collection集合都可以通过stream默认方法获取流
2.Stream接口的静态方法of可以获取数组对应的流

根据Collection获取流

首先java.util.Collection接口中加入了default方法stream用来获取流，所以其所有实现类均可获取流

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    // ...
    Stream<String> stream1 = list.stream();

    Set<String> set = new HashSet<>();
    // ...
    Stream<String> stream2 = set.stream();

    Vector<String> vector = new Vector<>();
    // ...
    Stream<String> stream3 = vector.stream();
    }

根据Map获取流

Java.util.Map接口不是Collection的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流需要分key、value或entry等情况：

public class Demo05GetStream {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        // ...
        Stream<String> keyStream = map.keySet().stream();
        Stream<String> valueStream = map.values().stream();
        Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();
    }
}

根据数组获取流

如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以 Stream 接口中提供了静态方法 of ，使用很简单：

public static void main(String[] args) {
     String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };
     Stream<String> stream = Stream.of(array);
}

备注： of 方法的参数其实是一个可变参数，所以支持数组。

流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：

延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。本小节中，终结方法包括 count 和 forEach 方法。

逐一处理：forEach

虽然方法名字叫 forEach，但是与for循环中的“for-each”昵称不同。
该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理。

void forEach(Consumer<? super ?> action);

复习Consumer接口

java.util.function.Consumer<T>接口是一个消费型接口。
Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。
    
import java.util.stream.Stream;
  public class Demo12StreamForEach {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若");
        stream.forEach(name‐> System.out.println(name));
    }
}

过滤：filter

可以通过 filter 方法将一个流转换成另一个子集流。方法签名：

Stream<T> filer(Predicate<? super T> predicate);

该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。

复习Predicate接口

此前我们已经学习过 java.util.stream.Predicate 函数式接口，其中唯一的抽象方法为：

boolean test(T t);

该方法会产生一个boolean值结果，代表指定的条件是否满足。如果结果为true，那么Stream流的filter方法将会留用元素；如果结果为false，那么filter方法将会舍弃元素。

基本使用

Stream流中的 filter 方法基本使用的代码如：

public class Demo07StreamFilter {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> result = original.filter(s ‐> s.startsWith("张"));
    }
}

映射：map

如果需要将流中的元素映射到另一个流中，可以使用map方法

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

该接口需要一个 Function 函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。

复习Function接口

此前我们已经学习过 java.util.stream.Function 函数式接口，其中唯一的抽象方法为：

R apply(T t);

这可以将一种T类型转换成R类型，这种转换的动作，叫做映射

基本使用

Stream流中的 map 方法基本使用的代码如：

public static void main(String[] args) {
    Stream<String> original = Stream.of("10","22","452");
    Stream<Integer> result = original.map(str -> Integer.parseInt(str));
    result.forEach(System.out::println);
}

这段代码中,map 方法的参数通过方法引用，将字符串类型转换成为了int类型（并自动装箱为 Integer 类对象）。

统计个数

正如旧集合 Collection 当中的 size 方法一样，流提供 count 方法来数一数其中的元素个数：

long count();

该方法返回一个long值代表元素个数

public static void main(String[] args) {
    Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
    Stream<String> result = original.filter(s ‐> s.startsWith("张"));
    System.out.println(result.count()); // 2
}

取用前几个：limit

limit 方法可以对流进行截取，只取用前n个。方法签名

Stream<T> limit(long maxSize);

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。基本使用:

public static void main(String[] args) {
    Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
    Stream<String> result = original.limit(2);
    result.forEach(System.out::println); // 张无忌 张三丰
    System.out.println(result.count()); // 2
    }
}

跳过前几个：skip

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：
如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。基本使用：

public class Demo11StreamSkip {
    public static void main(String[] args) {
         Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
         Stream<String> result = original.skip(2);
         result.forEach(System.out::println); // 周芷若
}

组合：concat

如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
// 这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。

public static void main(String[] args) {
    Stream<String> streamA = Stream.of("张无忌");
    Stream<String> streamB = Stream.of("张翠山");
    Stream<String> result = Stream.concat(streamA, streamB);
    }
}

集合元素处理(Stream方式）

题目(Stream流式处理方式)

第一个队伍只要名字为3个字的成员姓名；第一个队伍筛选之后只要前3个人；
第二个队伍只要姓张的成员姓名；第二个队伍筛选之后不要前2个人
将两个队伍合并为一个队伍；根据姓名创建Person对象；打印整个队伍的Person对象信息。

public class Person {
    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class test {
    public static void main(String[] args) {
        List<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");

        List<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");

        // 第一个队伍只要名字为3个字的成员姓名；第一个队伍筛选之后只要前3个人；
        Stream<String> streamOne = one.stream().filter(s -> s.length() == 3).limit(3);
        // 第二个队伍只要姓张的成员姓名；第二个队伍筛选之后不要前2个人；
        Stream<String> streamTwo = two.stream().filter(s -> s.startsWith("张")).skip(2);
        // 将两个队伍合并为一个队伍；根据姓名创建Person对象；打印整个队伍的Person对象信息。
        Stream.concat(streamOne, streamTwo).map(Person::new).forEach(System.out::println);

    }
}

Lambda方法引用

请注意其中的双冒号 :: 写法，这被称为“方法引用”，而双冒号是一种新的语法。

简单的函数式接口以应用Lambda表达式:
@FunctionalInterface
public interface Printable {
    void print(String str);
}

private static void printString(Printable data){
    data.print("Hello, World!");
}
public static void main(String[] args){
    printString(System.out::println);
}

方法引用符

引出：我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑?

双冒号 :: 为引用运算符，而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。

例如上例中， System.out 对象中有一个重载的 println(String) 方法恰好就是我们所需要的。那么对于 printString 方法的函数式接口参数，对比下面两种写法，完全等效：

Lambda表达式写法：s -> System.out.println(s);
方法引用写法：System.out::println

第一种语义是指：拿到参数之后经Lambda之手，继而传递给 System.out.println 方法去处理。
第二种等效写法的语义是指：直接让 System.out 中的 println 方法来取代Lambda。两种写法的执行效果完全一样，而第二种方法引用的写法复用了已有方案，更加简洁。

注：Lambda 中传递的参数一定是方法引用中的那个方法可以接收的类型,否则会抛出异常

三种主要使用情况：

情况1：对象名::实例方法名
情况2：类名::静态方法名
情况3：类名::实例方法名

【方法引用】Java语法中的双冒号::到底是啥意思？_哔哩哔哩_bilibili
lambda的双冒号是什么意思一个视频简简单单说清楚_哔哩哔哩_bilibili
【java面试技巧】双冒号之方法引用大家快来看看吧_哔哩哔哩_bilibili

interface A{
    int method(String str);
}

public class Test {
    public static void main(String[] args) {
        A a1 = str -> Integer.valueOf(str);
        System.out.println(a1.method("111"));

        A a2 = Integer::valueOf;
        System.out.println(a2.method("444"));

        A a = new A() { //因为A是接口所以直接new不了 加上大括号 匿名内部类
            @Override
            public int method(String str) {
                return new Integer(str); //封装 拆箱
            }
        };
        A a3 = Integer::new;
        System.out.println(a3.method("666"));
    }
}

推导与省略

如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式——它们都将被自动推导。而如果使用方法引用，也是同样可以根据上下文进行推导。
函数式接口是Lambda的基础，而方法引用是Lambda的孪生兄弟。下面这段代码将会调用 println 方法的不同重载形式，将函数式接口改为int类型的参数：

@FunctionalInterface
public interface PrintableInteger {
    void print(int str);
}
-------------------------------------------------------------
public class Demo03PrintOverload {
    private static void printInteger(PrintableInteger data) {
        data.print(1024);
}
public static void main(String[] args) {
    printInteger(System.out::println);
}
    // 这次方法引用将会自动匹配到 println(int) 的重载形式。

通过类名称引用静态方法

由于在 java.lang.Math 类中已经存在了静态方法 abs ，所以当我们需要通过Lambda来调用该方法时，有两种写法。首先是函数式接口：

@FuctionalInterface
public interface Calcable {
    double calc(int num);
}

private static void method(int num, Calcable lambda){
     System.out.println(lambda.calc(num));
}

public static void main(String[] args) {
     method(10, Math::sqrt);
    // method(‐10, n ‐> Math.abs(n)); 舍弃
}

在这个例子中，下面两种写法是等效的：

Lambda表达式: n -> Math.abs(n)
方法引用: Math::abs

通过super引用成员方法

如果存在继承关系，当Lambda中需要出现super调用时，也可以使用方法引用进行替代。首先是函数式接口：

public interface Greetable {
    void greet();
}

然后是父类Human内容

public class Human {
    public void sayHello(){
        System.out.println("Hello");
    }
}

最后是子类Man的内容，其中使用了Lambda写法

public class Man extends Human {
    @Override
    public void sayHello() {
        System.out.println("大家好，我是Man!");
    }
    //定义方法method，参数传递Greetable接口
    public void method(Greetable g){
        g.greet();
    }

    public void show(){
        method(super::sayHello);
    }

在这个例子中，下面两种写法是等效的：

Lambda表达式： () -> super.sayHello()
方法引用： super::sayHello

通过this引用成员方法

this代表当前对象，如果需要引用的方法就是当前类中的成员方法，那么可以使用**“this::成员方法”**的格式来使用方法引用。首先是简单的函数式接口：

@FunctionalInterface
public interface Richable {
    void buy();
}

下面是一个丈夫 Husband 类：

public class Husband {
    private void marry(Richable lambda) {
        lambda.buy();
    }
    public void beHappy() {
        marry(() ‐> System.out.println("买套房子"));
    }
}

开心方法 beHappy 调用了结婚方法 marry ，后者的参数为函数式接口 Richable ，所以需要一个Lambda表达式。但是如果这个Lambda表达式的内容已经在本类当中存在了，则可以对Husband丈夫类进行修改：

public class Husband {
    private void buyHouse() {
        System.out.println("买套房子");
    }
private void marry(Richable lambda) {
        lambda.buy();
    }
public void beHappy() {
        marry(() ‐> this.buyHouse());
    }
}

如果希望取消掉Lambda表达式，用方法引用进行替换，则更好的写法为：

public class Husband {
    private void buyHouse() {
        System.out.println("买套房子");
    }
private void marry(Richable lambda) {
        lambda.buy();
    }
public void beHappy() {
        marry(this::buyHouse);
    }
}

在这个例子中，下面两种写法是等效的：

Lambda表达式： () -> this.buyHouse()
方法引用： this::buyHouse

类的构造器引用

由于构造器的名称与类名完全一样，并不固定。所以构造器引用使用 类名称::new 的格式表示。首先是一个简单的Person类：

public class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

然后是用来创建 Person 对象的函数式接口：

public interface PersonBuilder {
    Person buildPerson(String name);
}

要使用这个函数式接口，可以通过Lambda表达式：

public class Demo09Lambda {
    public static void printName(String name, PersonBuilder builder) {
        System.out.println(builder.buildPerson(name).getName());
    }
    public static void main(String[] args) {
        printName("赵丽颖", name ‐> new Person(name));
    }
}

但是通过构造器引用，有更好的写法：

public class Demo10ConstructorRef {
    public static void printName(String name, PersonBuilder builder) {
           System.out.println(builder.buildPerson(name).getName());
    }
    public static void main(String[] args) {
        printName("赵丽颖", Person::new);
    }
}

在这个例子中，下面两种写法是等效的：

Lambda表达式： name -> new Person(name)
方法引用： Person::new

数组的构造器引用

数组也是 Object 的子类对象，所以同样具有构造器，只是语法稍有不同。如果对应到Lambda的使用场景中时，需要一个函数式接口：

@FunctionalInterface
public interface ArrayBuilder {
    int[] buildArray(int length);
}

在应用该接口的时候，可以通过Lambda表达式：

public class Demo11ArrayInitRef {
    private static int[] initArray(int length, ArrayBuilder builder) {
        return builder.buildArray(length);
    }
    public static void main(String[] args) {
        int[] array = initArray(10, length ‐> new int[length]);
    }
}

但是更好的写法是使用数组的构造器引用：

public class Demo12ArrayInitRef {
    private static int[] initArray(int length, ArrayBuilder builder) {
        return builder.buildArray(length);
    }
    public static void main(String[] args) {
        int[] array = initArray(10, int[]::new);
    }
}

在这个例子中，下面两种写法是等效的：

Lambda表达式： length -> new int[length]
方法引用： int[]::new

LOADING...

java复习款

Object类、常用API

请使用日期时间相关的API，计算出一个人已经出生了多少天。

Calendar类

CurrentTimeMillis方法

验证for循环打印数字1-9999所需要使用的时间（毫秒）

StringBuilder类

基本类型转换位String

Collection、泛型

Iterator迭代器

增强for

泛型

含有泛型的方法

含有泛型的接口

1、定义类时确定泛型的类型

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

泛型通配符

通配符高级使用—-受限泛型

扑克牌案例分析

List、Set、数据结构、Collections

List集合特有的方法都是跟索引相关

List(ArrayList、LinkedList)的子类

Set(HashSet、LinkedHashSet)

Set集合取出元素的方式可以采用：迭代器、增强for

HashSet存储自定义类型元素

可变参数

Collections(高效添加元素)

Comparator比较器

Map集合

Map集合遍历 键找值 方式

Map集合遍历键值对方式

LinkedHashMap

Map集合练习

JDK9对集合添加的优化

模拟斗地主洗牌发牌

案例规则

案例需求分析

异常体系

异常的处理

捕获异常try…catch

finally代码块

自定义异常练习

创建线程类

自定义线程类

继承Thread类方式

实现Runnable接口方式

Thread和Runnable的区别

实现Runnable接口比继承Thread类所具有的优势：

线程同时安全

怎么使用Java线程同步机制 ？

同步代码块

同步方法

Lock锁

线程状态概述

等待唤醒机制

调用wait和notify方法需要注意的细节

线程池

Lambda表达式

强调做什么，而不是以什么形式做

代码分析

传统代码

使用匿名内部类

Lambda标准格式

Lambda的参数和返回值

代码分析

Lambda写法

省略规则

File类

常用方法

绝对路径和相对路径

判断功能的方法

创建删除功能的方法

目录的遍历

递归

递归打印多级目录

文件搜索案例

文件过滤器优化

Lambda优化

字节流、字符流

Map集合遍历键找值方式

怎么使用Java线程同步机制？